From 00a8df6f8f9459ef91ed9c0f82d6446fa07fd727 Mon Sep 17 00:00:00 2001 From: Sy Date: Mon, 25 May 2020 14:34:07 +0200 Subject: [PATCH] generated CN processing files according to the values of Z | version for AVX2 and AVX512| BG1 & BG2 --- .../CODING/nrLDPC_decoder/nrLDPC_decoder.c | 1121 ++++++++++++++++- .../nrLDPC_tools/generator_avx2/Makefile | 2 +- ...nProc_gen_avx2.c => cnProc_gen_BG1_avx2.c} | 0 .../generator_avx2/cnProc_gen_BG2_avx2.c | 425 +++++++ .../generator_avx2/cnProc_gen_avx2 | Bin 188432 -> 205784 bytes .../nrLDPC_tools/generator_avx2/main.c | 2 + .../nrLDPC_tools/generator_avx512/Makefile | 2 +- ...c_gen_avx512.c => cnProc_gen_BG1_avx512.c} | 0 .../generator_avx512/cnProc_gen_BG2_avx512.c | 475 +++++++ .../generator_avx512/cnProc_gen_avx512 | Bin 192544 -> 205888 bytes .../nrLDPC_tools/generator_avx512/main.c | 2 + .../avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c | 1 - .../avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c | 823 ++++++++++++ .../avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c | 823 ++++++++++++ .../nrLDPC_cnProc_BG2_Z104_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z10_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z112_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z11_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z120_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z128_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z12_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z13_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z144_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z14_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z15_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z160_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z16_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z176_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z18_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z192_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z208_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z20_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z224_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z22_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z240_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z24_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z256_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z26_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z288_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z28_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z2_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z30_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z320_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z32_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z352_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z36_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z384_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z3_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z40_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z44_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z48_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z4_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z52_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z56_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z5_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z60_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z64_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z6_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z72_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z7_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z80_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z88_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z8_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z96_13_AVX512.c | 829 ++++++++++++ .../nrLDPC_cnProc_BG2_Z9_13_AVX512.c | 829 ++++++++++++ 114 files changed, 86269 insertions(+), 13 deletions(-) rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/{cnProc_gen_avx2.c => cnProc_gen_BG1_avx2.c} (100%) create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/{cnProc_gen_avx512.c => cnProc_gen_BG1_avx512.c} (100%) create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG2_avx512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_13_AVX512.c diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c index fd36a68eac..214b1e2c10 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c @@ -1,3 +1,4 @@ + /* * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more * contributor license agreements. See the NOTICE file distributed with @@ -28,6 +29,7 @@ * \warning */ + #include #include #include "nrLDPCdecoder_defs.h" @@ -36,7 +38,10 @@ #include "nrLDPC_mPass.h" #include "nrLDPC_cnProc.h" #include "nrLDPC_bnProc.h" -//include files-> AVX2 + +/*********************************include files-> AVX2**********************/ +/*----------------------------BG1-----------------------------------------*/ + #include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c" #include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c" #include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c" @@ -93,8 +98,68 @@ #include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c" #include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c" +/*----------------------------BG2---------------------------------------*/ -//include files for -->AVX512 +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c" + +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c" + +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c" + +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c" + +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c" +#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c" + + + + +/**************************include files for -->AVX512 ******************/ //#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c" /*#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c" @@ -608,7 +673,353 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP } else { - nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); + //nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); + + + + // depend on Z + switch (Z) + { + case 384: + { + nrLDPC_cnProc_BG2_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 352: + { + nrLDPC_cnProc_BG2_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 320: + { + nrLDPC_cnProc_BG2_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 288: + { + nrLDPC_cnProc_BG2_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 256: + { + nrLDPC_cnProc_BG2_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //LDPC_cnProc_BG2_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 240: + { + + nrLDPC_cnProc_BG2_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 224: + { + + nrLDPC_cnProc_BG2_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 208: + { + nrLDPC_cnProc_BG2_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 192: + { + nrLDPC_cnProc_BG2_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 176: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 160: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 144: + { + nrLDPC_cnProc_BG2_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 128: + { + nrLDPC_cnProc_BG2_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 120: + { + nrLDPC_cnProc_BG2_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 112: + { + nrLDPC_cnProc_BG2_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 104: + { + nrLDPC_cnProc_BG2_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 96: + { + nrLDPC_cnProc_BG2_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 88: + { + nrLDPC_cnProc_BG2_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 80: + { + nrLDPC_cnProc_BG2_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + + case 72: + { + nrLDPC_cnProc_BG2_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 64: + { + nrLDPC_cnProc_BG2_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 60: + { + nrLDPC_cnProc_BG2_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 56: + { + nrLDPC_cnProc_BG2_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + + } + case 52: + { + nrLDPC_cnProc_BG2_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 48: + { + nrLDPC_cnProc_BG2_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 44: + { + nrLDPC_cnProc_BG2_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 40: + { + nrLDPC_cnProc_BG2_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 36: + { + nrLDPC_cnProc_BG2_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 32: + { + nrLDPC_cnProc_BG2_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 30: + { + nrLDPC_cnProc_BG2_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 28: + { + nrLDPC_cnProc_BG2_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 26: + { + nrLDPC_cnProc_BG2_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 24: + { + nrLDPC_cnProc_BG2_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 22: + { + nrLDPC_cnProc_BG2_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 20: + { + nrLDPC_cnProc_BG2_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 18: + { + nrLDPC_cnProc_BG2_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 16: + { + nrLDPC_cnProc_BG2_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 15: + { + nrLDPC_cnProc_BG2_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 14: + { + nrLDPC_cnProc_BG2_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 13: + { + nrLDPC_cnProc_BG2_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 12: + { + nrLDPC_cnProc_BG2_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 11: + { + nrLDPC_cnProc_BG2_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 10: + { + nrLDPC_cnProc_BG2_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 9: + { + nrLDPC_cnProc_BG2_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 8: + { + nrLDPC_cnProc_BG2_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 7: + { + nrLDPC_cnProc_BG2_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 6: + { + nrLDPC_cnProc_BG2_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 5: + { + nrLDPC_cnProc_BG2_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 4: + { + nrLDPC_cnProc_BG2_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 3: + { + nrLDPC_cnProc_BG2_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 2: + { + nrLDPC_cnProc_BG2_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + }//end switch(Z) } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); @@ -701,10 +1112,10 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->cnProc); #endif - if (BG == 1){ + if (BG == 1){ // depend on Z - switch (Z) - { + switch (Z) + { case 384: { nrLDPC_cnProc_BG1_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); @@ -1052,8 +1463,352 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP } else { - nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); + //nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); + + // depend on Z + switch (Z) + { + case 384: + { + nrLDPC_cnProc_BG2_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; } + case 352: + { + nrLDPC_cnProc_BG2_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 320: + { + nrLDPC_cnProc_BG2_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 288: + { + nrLDPC_cnProc_BG2_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 256: + { + nrLDPC_cnProc_BG2_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //LDPC_cnProc_BG2_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 240: + { + + nrLDPC_cnProc_BG2_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 224: + { + + nrLDPC_cnProc_BG2_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 208: + { + nrLDPC_cnProc_BG2_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 192: + { + nrLDPC_cnProc_BG2_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 176: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 160: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 144: + { + nrLDPC_cnProc_BG2_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 128: + { + nrLDPC_cnProc_BG2_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 120: + { + nrLDPC_cnProc_BG2_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 112: + { + nrLDPC_cnProc_BG2_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 104: + { + nrLDPC_cnProc_BG2_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 96: + { + nrLDPC_cnProc_BG2_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 88: + { + nrLDPC_cnProc_BG2_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 80: + { + nrLDPC_cnProc_BG2_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + + case 72: + { + nrLDPC_cnProc_BG2_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 64: + { + nrLDPC_cnProc_BG2_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 60: + { + nrLDPC_cnProc_BG2_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 56: + { + nrLDPC_cnProc_BG2_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + + } + case 52: + { + nrLDPC_cnProc_BG2_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 48: + { + nrLDPC_cnProc_BG2_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 44: + { + nrLDPC_cnProc_BG2_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 40: + { + nrLDPC_cnProc_BG2_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 36: + { + nrLDPC_cnProc_BG2_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 32: + { + nrLDPC_cnProc_BG2_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 30: + { + nrLDPC_cnProc_BG2_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 28: + { + nrLDPC_cnProc_BG2_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 26: + { + nrLDPC_cnProc_BG2_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 24: + { + nrLDPC_cnProc_BG2_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 22: + { + nrLDPC_cnProc_BG2_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 20: + { + nrLDPC_cnProc_BG2_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 18: + { + nrLDPC_cnProc_BG2_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 16: + { + nrLDPC_cnProc_BG2_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 15: + { + nrLDPC_cnProc_BG2_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 14: + { + nrLDPC_cnProc_BG2_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 13: + { + nrLDPC_cnProc_BG2_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 12: + { + nrLDPC_cnProc_BG2_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 11: + { + nrLDPC_cnProc_BG2_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 10: + { + nrLDPC_cnProc_BG2_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 9: + { + nrLDPC_cnProc_BG2_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 8: + { + nrLDPC_cnProc_BG2_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 7: + { + nrLDPC_cnProc_BG2_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 6: + { + nrLDPC_cnProc_BG2_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 5: + { + nrLDPC_cnProc_BG2_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 4: + { + nrLDPC_cnProc_BG2_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 3: + { + nrLDPC_cnProc_BG2_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 2: + { + nrLDPC_cnProc_BG2_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + }//end switch(Z) + } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); #endif @@ -1305,7 +2060,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP // nrLDPC_cnProc_BG1_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); break; } - + case 60: { nrLDPC_cnProc_BG1_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); @@ -1507,8 +2262,354 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP } else { - nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); - } + // nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); + // depend on Z + switch (Z) + { + case 384: + { + nrLDPC_cnProc_BG2_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 352: + { + nrLDPC_cnProc_BG2_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 320: + { + nrLDPC_cnProc_BG2_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + + case 288: + { + nrLDPC_cnProc_BG2_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 256: + { + nrLDPC_cnProc_BG2_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //LDPC_cnProc_BG2_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 240: + { + + nrLDPC_cnProc_BG2_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 224: + { + + nrLDPC_cnProc_BG2_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + //nrLDPC_cnProc_BG2_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 208: + { + nrLDPC_cnProc_BG2_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 192: + { + nrLDPC_cnProc_BG2_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 176: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 160: + { + nrLDPC_cnProc_BG2_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 144: + { + nrLDPC_cnProc_BG2_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 128: + { + nrLDPC_cnProc_BG2_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 120: + { + nrLDPC_cnProc_BG2_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 112: + { + nrLDPC_cnProc_BG2_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + case 104: + { + nrLDPC_cnProc_BG2_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 96: + { + nrLDPC_cnProc_BG2_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 88: + { + nrLDPC_cnProc_BG2_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 80: + { + nrLDPC_cnProc_BG2_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + + + case 72: + { + nrLDPC_cnProc_BG2_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 64: + { + nrLDPC_cnProc_BG2_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 60: + { + nrLDPC_cnProc_BG2_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 56: + { + nrLDPC_cnProc_BG2_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + + } + case 52: + { + nrLDPC_cnProc_BG2_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 48: + { + nrLDPC_cnProc_BG2_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 44: + { + nrLDPC_cnProc_BG2_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 40: + { + nrLDPC_cnProc_BG2_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 36: + { + nrLDPC_cnProc_BG2_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 32: + { + nrLDPC_cnProc_BG2_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 30: + { + nrLDPC_cnProc_BG2_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 28: + { + nrLDPC_cnProc_BG2_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 26: + { + nrLDPC_cnProc_BG2_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 24: + { + nrLDPC_cnProc_BG2_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 22: + { + nrLDPC_cnProc_BG2_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 20: + { + nrLDPC_cnProc_BG2_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 18: + { + nrLDPC_cnProc_BG2_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 16: + { + nrLDPC_cnProc_BG2_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 15: + { + nrLDPC_cnProc_BG2_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 14: + { + nrLDPC_cnProc_BG2_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 13: + { + nrLDPC_cnProc_BG2_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 12: + { + nrLDPC_cnProc_BG2_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 11: + { + nrLDPC_cnProc_BG2_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 10: + { + nrLDPC_cnProc_BG2_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 9: + { + nrLDPC_cnProc_BG2_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 8: + { + nrLDPC_cnProc_BG2_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 7: + { + nrLDPC_cnProc_BG2_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 6: + { + nrLDPC_cnProc_BG2_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + + case 5: + { + nrLDPC_cnProc_BG2_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 4: + { + nrLDPC_cnProc_BG2_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 3: + { + nrLDPC_cnProc_BG2_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + case 2: + { + nrLDPC_cnProc_BG2_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + // nrLDPC_cnProc_BG2_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes); + break; + } + }//end switch(Z) + } + #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); #endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile index abb9f8fd2f..5f58a090ec 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile @@ -24,4 +24,4 @@ mrproper: clean @rm -rf $(EXEC) zip: - @tar -zcvf sauvegarde.tar.gz main.c cnProc_gen_avx2.c cnProc_gen_avx2.h Makefile + @tar -zcvf sauvegarde.tar.gz main.c cnProc_gen_BG1_avx2.c cnProc_gen_BG2_avx2.c Makefile diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG1_avx2.c similarity index 100% rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG1_avx2.c diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c new file mode 100644 index 0000000000..01d25fb829 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c @@ -0,0 +1,425 @@ +#include +#include +#include "../../nrLDPCdecoder_defs.h" +#include "../../nrLDPC_types.h" +#include "../../nrLDPC_bnProc.h" + + +void nrLDPC_cnProc_BG2_generator_AVX2(uint16_t Z,int R) +{ + const char *ratestr[3]={"13","23","89"}; + + if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();} + + +// system("mkdir -p ldpc_gen_files/avx2"); + + char fname[50]; + sprintf(fname,"../ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z%d_%s_AVX2.c",Z,ratestr[R]); + FILE *fd=fopen(fname,"w"); + if (fd == NULL) {printf("Cannot create \n");abort();} + + fprintf(fd,"#include \n"); + fprintf(fd,"#include \n"); + fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_%s_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]); + + const uint8_t* lut_numCnInCnGroups; + const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG2; + + if (R==0) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R15; + else if (R==1) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R13; + else if (R==2) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R23; + else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();} + + + // Number of CNs in Groups + uint32_t M; + uint32_t j; + uint32_t k; + // Offset to each bit within a group in terms of 32 byte + uint32_t bitOffsetInGroup; + + // Offsets are in units of bitOffsetInGroup (1*384/32) + // const uint8_t lut_idxCnProcG3[3][2] = {{12,24}, {0,24}, {0,12}}; + + // ===================================================================== + // Process group with 3 BNs + fprintf(fd,"//Process group with 3 BNs\n"); + // LUT with offsets for bits that need to be processed + // 1. bit proc requires LLRs of 2. and 3. bit, 2.bits of 1. and 3. etc. + // Offsets are in units of bitOffsetInGroup + const uint8_t lut_idxCnProcG3[3][2] = {{72,144}, {0,144}, {0,72}}; + + + fprintf(fd," __m256i ymm0, min, sgn,ones,maxLLR;\n"); + fprintf(fd," ones = _mm256_set1_epi8((char)1);\n"); + fprintf(fd," maxLLR = _mm256_set1_epi8((char)127);\n"); + + if (lut_numCnInCnGroups[0] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[0]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[0]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<3; j++) + { + + fprintf(fd," for (int i=0;i<%d;i+=2) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + // 32 CNs of second BN + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][1]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[0]>>5)+(j*bitOffsetInGroup)); + + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][0]+1); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + // 32 CNs of second BN + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][1]+1); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[0]>>5)+(j*bitOffsetInGroup)+1); + + fprintf(fd," }\n"); + } + } + + // ===================================================================== + // Process group with 4 BNs + fprintf(fd,"//Process group with 4 BNs\n"); + + // Offset is 20*384/32 = 240 + const uint16_t lut_idxCnProcG4[4][3] = {{240,480,720}, {0,480,720}, {0,240,720}, {0,240,480}}; + + if (lut_numCnInCnGroups[1] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[1]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[1]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<4; j++) + { + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>5)+lut_idxCnProcG4[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + + // Loop over BNs + for (k=1; k<3; k++) + { + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>5)+lut_idxCnProcG4[j][k]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + } + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[1]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + // ===================================================================== + // Process group with 5 BNs + fprintf(fd,"//Process group with 5 BNs\n"); + + // Offset is 9*384/32 = 108 + const uint16_t lut_idxCnProcG5[5][4] = {{108,216,324,432}, {0,216,324,432}, + {0,108,324,432}, {0,108,216,432}, {0,108,216,324}}; + + + + if (lut_numCnInCnGroups[2] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[2]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[2]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<5; j++) + { + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>5)+lut_idxCnProcG5[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + + // Loop over BNs + for (k=1; k<4; k++) + { + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>5)+lut_idxCnProcG5[j][k]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + } + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[2]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + // ===================================================================== + // Process group with 6 BNs + fprintf(fd,"//Process group with 6 BNs\n"); + // Offset is 3*384/32 = 36 + const uint16_t lut_idxCnProcG6[6][5] = {{36,72,108,144,180}, {0,72,108,144,180}, + {0,36,108,144,180}, {0,36,72,144,180}, + {0,36,72,108,180}, {0,36,72,108,144}}; + + + if (lut_numCnInCnGroups[3] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[3]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[3]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<6; j++) + { + + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>5)+lut_idxCnProcG6[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + + // Loop over BNs + for (k=1; k<5; k++) + { + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>5)+lut_idxCnProcG6[j][k]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + } + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[3]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + + // ===================================================================== + // Process group with 8 BNs + fprintf(fd,"//Process group with 8 BNs\n"); + // Offset is 2*384/32 = 24 + const uint8_t lut_idxCnProcG8[8][7] = {{24,48,72,96,120,144,168}, {0,48,72,96,120,144,168}, + {0,24,72,96,120,144,168}, {0,24,48,96,120,144,168}, + {0,24,48,72,120,144,168}, {0,24,48,72,96,144,168}, + {0,24,48,72,96,120,168}, {0,24,48,72,96,120,144}}; + + + + + + + if (lut_numCnInCnGroups[4] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[4]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[4]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<8; j++) + { + + // Loop over CNs + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[4]>>5)+lut_idxCnProcG8[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + // Loop over BNs + for (k=1; k<7; k++) + { + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[4]>>5)+lut_idxCnProcG8[j][k]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + + } + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[4]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + // ===================================================================== + // Process group with 10 BNs + fprintf(fd,"//Process group with 10 BNs\n"); + + const uint8_t lut_idxCnProcG10[10][9] = {{24,48,72,96,120,144,168,192,216}, {0,48,72,96,120,144,168,192,216}, + {0,24,72,96,120,144,168,192,216}, {0,24,48,96,120,144,168,192,216}, + {0,24,48,72,120,144,168,192,216}, {0,24,48,72,96,144,168,192,216}, + {0,24,48,72,96,120,168,192,216}, {0,24,48,72,96,120,144,192,216}, + {0,24,48,72,96,120,144,168,216}, {0,24,48,72,96,120,144,168,192}}; + + + + + + if (lut_numCnInCnGroups[5] > 0) + { + // Number of groups of 32 CNs for parallel processing + // Ceil for values not divisible by 32 + M = (lut_numCnInCnGroups[5]*Z + 31)>>5; + + // Set the offset to each bit within a group in terms of 32 byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[5]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<10; j++) + { + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 32 CNs (first BN) + // ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>5)+lut_idxCnProcG10[j][0]); + // sgn = _mm256_sign_epi8(ones, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(ones, ymm0);\n"); + // min = _mm256_abs_epi8(ymm0); + fprintf(fd," min = _mm256_abs_epi8(ymm0);\n"); + + + // Loop over BNs + for (k=1; k<9; k++) + { + fprintf(fd," ymm0 = ((__m256i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>5)+lut_idxCnProcG10[j][k]); + + // min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + fprintf(fd," min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n"); + + // sgn = _mm256_sign_epi8(sgn, ymm0); + fprintf(fd," sgn = _mm256_sign_epi8(sgn, ymm0);\n"); + } + + // Store result + // min = _mm256_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm256_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m256i*)cnProcBufRes)[%d+i] = _mm256_sign_epi8(min, sgn);\n",(lut_startAddrCnGroups[5]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + fprintf(fd,"}\n"); + fclose(fd); +}//end of the function nrLDPC_cnProc_BG2 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2 index 06ab2452c9c35aaf79146f239cccae9ccd686693..1d463e5c746fd4c49d0a36ca10bc7646c83de306 100644 GIT binary patch literal 205784 zcmeFa2fSWIwYa_aNltn%q$ekk-V>4#Y62v9=%IHKAPEFRh$J9bFcJd907g+jYzQLg z1wpThas>lwK(7TmmaFI$4YrHQ_3yP@zUP_s?(>$@-k@Lk{XXWLchBsZSu<++OkvIB$iUQi7XOf-C%|qqwZ_i}u+zeSh6g>ZuLsNX=w+D9uaN=378&Jx4VyV9N=<-6TeT84T&1SD#d;Y@t zv)8Sfxo++H%deby<)Vc%7tWux@zPoIQoAkRystX$lvGne$0qJ<-w=Mvfaz0@y!GcJ zPx;6*+4PToVbIf``@qndtM?bS_z|qz%_irdHgb<>Cw@UY@nhSGm;P;)e{?(Xhqn`d z4)IO=YTaNW+A6BiOBn%7>ob`xF+Zp8}A65_H=D=s;2?Rvm3 zyyVjLrI;1jtByJHu)|l(n>D{BG;fx4ZAgDzN`7%q0xl<3{uXjLWbN9%O2oQS+~p(J z_7vg@GvogJrt^}oj2C^(h~b+fzB^&dD_m1Wd`p)maY{veS)*myoQinmvv7+l;w$ye zl8X4se%D+PFHVJ9UJ*~jTHNUs@x5ANvutHWyu2@5^OoQAXx`p<@ax8B&0BYFYTW&A zq%?2&LXXc!j+Yk9Bk84y^SSmPw}g=Q7n%6{voGN$PV-(;J^ysN-`jgh^!(0rKhk?i z^ZY~UevtQ)~%1?$_+#KDoKSJ#yPO&TZcIv*s;7e_{E_M?Sgpp~IJC%}+kQBzaG6KXgg9`?UbR zxTgO&I^(C`1ffo8o_Qr+^OisNYu@(U6{9|FQIcoiIiEA(rDw@}Z7Tnq&r6jxvx@u2 zOh2Xh&A&?pJpR93D4==U3(b%3Ufi7TYW~LmZW`KBTJNH?{^PQ9J|FdOK6rod&n_Q$ z3V^%UgV;H{8YdBz|1s6{xh5VM&07{{mpA_U7T{V6`@H}!J$=seuLH(#^P7M3ENt2K z=WU;y^1m;=v}W7Z8F;Ijw|AX5#pY~V_UE}fo1fgef!NJQN|UWu65JBO%>=I_xaCoS zvnzW>pyBG#+qW9CZP(|vk({dEJ(-BzKl}SjFGX7O?akY7{G#RdfB2nN+I-WposZpa z!P}k;hy_LL*CTfK5F@s2U9Pv~QN8T){-65>sk`4r!Mm^J(!4#=w>|!d>i#iWmwoP8 zv;3(#by!R4f1CPD2be{Xj}17g0=X+K?a8gDgT$PrEhMZ47R$Kwt?m=L+YwJo0v}@~m zcsq7&Js&UIwe^CyTNQV!@tP}WHNT~t+b!qI)wPsUpEmXW>ePiTusx0@_2x*G3jIHo zUAwdYwUg-C)K!Y<|EZ_@Kb+*O|AS9#**WgO+4EmTYixg~*-O|zwuDMsWag)TO$oAPd-nM5#%)h*Pq6(zb?q|A(*ILC z^Ct?(iz*@S4ag*12#?Q_5S}}2)Mu(wXSJk0W9qv*s8uesU+diJa#1d&T6-KrxrbM$ zmf5h})QRn--e79?_HcS|t0XN`VJEp;==XuYbWXpgZ(5$WNy1eD+ztt^s7{^L($qx4 z(>tiRAYr=||N4Jg#Gx79)ll*8)u}a9{7HMMiHeU$YHN8aQLz%GDng!KU2MOW*7iFV z=3GqbmL!<@mPeKChW^)0s@6~Co;^m0ML?{1a_bKAzK{`kJAr3&0`DO3bOV7~31lYS zUL@U7B)z9ddLMxVerJ(%SCRC=BI!c}o|VD&*XAud^HMLKPtU84ZNDcEp}C#)T(o^H-}Hs^8O-8^#xW%YlU|D87tXS)u}b&+eGS?z-`N;Vt^#A;OSnf$nH>vNFx2aKc&=a^b0lFp>nu3AdCK8Bh$B% zS|!t6`d>F%8kL{OWtm>1Os@h0d3}gX>lECN6L`kJCkQN6xIabUAp@T#kc9h@BF|@w zJdYK5b{2V_Adm|DLXl@zk>{x*&zFllUm=hx{aTUd=_1cJi#*>h@_d)T(u%&(Q0g0F ztNMnq?e~qIb@YwLJMJ5QeX){-J*uB{4`2I5DT=(6b$r#6?$LlQ*jUpQzFwVL(-l5O zYDHIgYgJb$A@cb4B#))8@c7Rf=&1IB5?1Z?&`H%5*Ytu#)v0BfPLINoq*nC;WN%f6 zyKlMw#A0YE>`j+W)$Fu%pdhutSJ*fk48WKzD+|zqfcB zm_Q(j@gxE}jG02<69%RcNZnxufs}a`fs}a;fs}b3fs}bZfs}b6fmFpJ0x9zW1XAXM z2&Bx15J;Jq5J;I1Bao_CN+4xEfi3C#SlL@5E zrxHk+PbZKvpGjax#Z#tBsedi3>R-mT-@lwjcJ}P~e#iam-MGZT&gkmAke+hsQkX7kKyW z+WJd8rc=A|0C*k`fM4MO@M}B(euD?VZ}9;59UcJxg-1m%-~sS^JOKWH2f!ck0C*7( zfd9q=;7@n}{2x3j`ZFE?|APm>U+@6eeeM2iw8hIJOKLRQPBWA00!a# zFbEHT!FT`+!2@6@9sqmc0Wb`22l7%HZFVj7`2DJSys_=~c(QideQO7m}s|+ zIr&p|;E4&7iZ0*1|8*mj`m*wIB_|-hFT@{zoy;R(i%_12hftm`?wCjL5K0FP2<2)# zq<;+_!h9j#&RttC!h2@d*0p$u_QiOBzZwtlb$EbZf(N)JIlwQ)1AGG>;IF|0{4zYi zH{uQ7wRIC7;Fse8egz)juf+rWN<6@?!UOzuc!0ki5AZkO0scljkhmHT@HgRIxog?x z9lMsj`MzDtuGzV3*_LN^ExR_`wQTF~UCXYUvuoM)&AXP}K%Q;nc?)^AljlbA+(e$6 z$@5n7>>$tER_@i-B<2f_8#)Qmptzy&-=-9 zCwV?Vp1a6%H+eoto_i?kL*%)aJol03!{qr0dH#hw_mk%V@_dv$4^q}c`tvM5Uf!dcT}g=sEjv|TBS02 zbfz+nit?&yTbIgs_Lo(7){GMVKx)=Tc3O?1Rr$wCBm)mvg&&d1YLc zJsq&!Pms!(2Bi8hrolt!4iZJiG;ud1?uO#^si0N42i$HsudA-5ocgq>XIG~#Y>~ho zr;vI`q}tw+qAS_cOEID3WO;=>{RM76%|NB~xadVvp4_^dE2)J&-RvdoA6r7DEi&`A zpQi-b(qd&0R(rZ+DJ?C&!{Z42Ps)Bwc8**zB4yi_{ z;-MgsCRL}_kg!Jw6&ECIx8isItRpHuP@P&s#kaPXnyC1iNNtyjl_*savPX5X6?*+N zXfcx1ElH@E{VAVidwL;&W!vKzA$I@Np525n9kgrfcs#~kd*gj#*VcXT=-?9~(p45B zCq?9BJOHLd)FDvZk3t}cy5!-%`b%~qQ>J_k>9{Wt1$yD`N8q^|j zKY6yL$Cj3@vD*3Ujn-&@Z0jJSRgWIF@P>r zRAV@|yiZ1L)lFbflJsGRTHxqvJZpsaoP>#`l!O=K<*1m)6fG+Y?;3@7IuKX^mqW~C zx;~LWGLxT7;070iP9?Ci3xU%KB&*w*MV_;ZJm(g9Ru*~ACy)wURpePyze(dYrjMsk6=zhVyni#}ogN7+hju z*>Ij%h~Zp{7KZcI;&yF77fh+?4!2gP)^vv}Nv-G(Z>{PMWy5(zcPJaqOIU^Byfs?C z{ZWIG%PdC|-=MAG07MtN z1t#TQutSK6Kp^2e;n_-!;!hCRY2XV4np`#7MPRdmrwF9g(k~N8-Qg<)Qs%D_NSU7| zkTQRhK+61W0x9!%39Pi_X9%RsKOm4Y|A;`!{9^(s^Rom}=ARMRDb&viq|Cn{kTUNk zkTU;@K+60Z0x9$F2sDZF3j|W;KM+WnUnGz+|A|1#{AU6w^Ir&Tc44a2lWGj-6|wC< ze0tQ;zrt|dZvQ&}2bKM+Y&e&#K70zhG;6m!fR^|GsxX|(=juV^peU~pfSMjRp*ppu z$8{sMqQ||ns>hX3YxMvs5KM-1C9B17-Ws{fzu!^6yS_TL+>6p!b1kV={jO{{FB)5h zNd0cVD6iD-%7*i#x;pH4Uwx(u&zh&tPe`pAI+YFQ1t#TwcfbAa0U(gi<$q%+q2qdUY1QOI01QOJh1X881BaoopKp;U~O&~#SCXk@6A&{W1 zC6J)5BakY+fk1+K3xNc6BY_0v_NN53gFu3MJAnlC4g#stTL~nn+X*D7I|wAG_Yg=> z?<0_)-0_v5?jkUwqK_A*a<{XWdw$te-qtg;o&n|$J04(O{oTqwUN)5%eLOa1q>e-% ze~9I{j{EqmD6bHgCFD2fh5Q->K?7 zHBZ+MRHv5vZ0hA(NUiGS^sTdBsw%Gxk$U+FQC_K+mu=;p_wrwUyQ@u=udJODm`2f$r;0NjlSzz6XFxCak_ z58(meHbE-74-bG3;{osyJOKU$4}kme0C)fofREw<@E{%)J%k6q$M697I3581iU+_a z@BsKE9sr-h1K?pim&Zy^@ETipMQr=ebuF5mjhkb6tlj7OTfPZuEwi_>t-I*+k3U;1 zK+W9jLtWE*X?e_kUHwo$I0|d0!yjLrTGQd@l3LN>-&NJ&%eL<74qwL3X=NpXZBHxT z^NrNn0>PRt|IzByatBUbeg~;lUB0|LR+LwUNL~KiD6iDzOKqrYTKVGBRd|+{$9`@H z?v^l-L#1hDd3mhBr2Jt2Zy~--d8`UQNZX6zPO?beK#{+I}JmB`hquL30z)i#h zZW11FlktF?f(P7GJm99`0XH2FxEXjWcWs@C2iz6xp=_M!vk(#JmBWz z0k;5;Y8T=Gw;vvGi|~Nk9}l<#@PIoI54eNyfIAouxI^%$b}=4sOYnd@6c4z=@PIoU z54fdxz%9cA?g%{KUWIpGS;cfKS(*2)8dezlkExh1c08<@{53FaQ8B}7t<7IlEZevH zKL6DOT?lr~AmXppsWm#~KS-_6DYsPVloBHBX{*pFkN>PobN(y00L{!gRd>f#S6-t{ zR#vB$bwko7hml&PP3XfbI~+g^i1JF>q=t+gP7^-#l`0a}3?M#DYSjROHN08X1BlTO zE>_M4o{l!T4hSB2u#L5okKrMWAIF=(0}l_O`~)7x)KB6eo1elvnFk&oBKm2(b-T8H z1`lC=1P}0k!vp-Ycz{2O2l!)nfPW4T@SS*oKaL0Z6L^4s9uFkGfCsqmQ2@RR5AY}P z0DlS(@Gs#3{$)JC{~ZtTuiydxRXmXR8Xn+Z#{>LnJixz!2lzMf0RI*q;NQjr{5yDn ze-{t%@8N;OGkAc19}n;!-~s+aJivd12l#*B0sdn=z<+`V__KI`{}c}-eufA5f8qiD zb3DMG!vp*mc!2*B5AfZ1fIp81_^e*3m)KI@c?hc1H2m^;N9^6?|}z+PrQ|7UDmy%%SyY6O2Z{%+t+29tN+2_ z(pg^urxsl{x@BuX<#4IAHDI~(qYj5l{i3jTR9jPZYK>}ZAhklZRS%a+c(q{zLA#}m z3l5hm5o~+7bjeexwFQDT3hqtSsWl4jJW{I^TzP9iQC=A$4VPv|c_jr`YC~Par7u2N zg=dX|`yQ!P3a-30punW8;AW}d?y(PAElCI4+o!GT3mOV;hc|g@8*4XyNlIKjPV)-8(KVrYIt5PhR+7ruS>iz=Q zbv$+77zGyesd?&dtxl~G%?nAb5Y6iKp%QNGiYE5MGg|LgXue)KxUi%0L#N@nlM z@}As%;};m`)oxn3p2*Usl`UV`T(d=G&6CS^G+@A6_VzAb-_h0Ut&Lu9@8VZZUOzG1>!(I~{q$(B zkBs&D*(R@#xmkSK&M97>nBnycbG+`F@AaugUcapIY}r?qc>S7t%9lO8-0L?__xkOX zUcY;h*Jn0({ed>NWk1^N^~XEBK6|IvpFQOD=R3Xr;%TqDpY{5y7rg!^!-To)cUs(+ zy|BdVA69yOadZCUvK!$+_Unb)m)+QWd;f=*F57`%K4#puCwD*lLsmK4N_Z_?*s|=# ze9IeeoOksX(l(Xm?WefAXh?bkm)%7_enLi--yUAGBwz=I&#~0j+y#gdT0CbzjxWa81Uw;zunX{_lL#%$H#2@)iK-tw3HHF z8uFv&EuYVu_y6_fzw(9dv(7p6>_g8v^xQ*Ne11o{#y@@@z2-aMrB}XvkNzKZ&cZkE z&F{nfeotwW&|Qb{JA+?(RlKGK=c)|NH-9(sZ|<3AUAi`Q>)xYhFV8Q~<&A@SG&VHk zs!AOtWnF6SjW5y->&A}m-n(bl9({Ur@6)SK?_S+|_3GQbNAEt3-FzVx*Qa;a#zrb@ z?9vU#wXqvDck9xnM25z$UD|RD4Gm)0qgS^fJwYSu(cLS=cewRjE#dY!KCD~!%fAr?#vlFt@HlM{C{TFOrRgt5^Ahq}3yjM1A^Tf?_vwf*4 z&$?}%m~biJz$t6ycLJ$r@w<@UHT>Sj?{4BB=JyqTKj+u@GU#J}^1u;<2^R`^YwxVB&_<2tOoj>O8cUQW0Z^gB(S zyKgpc-)zzT*^%qkt-kQQbxkKWO(^hpsp*2tR-dV*O>wCqqGHcggIHPH8Rr6-g7XQ^7H#S{(*`=3nXnO71O&2xo z+jQ7*8|~)0rW&_m#U=9=EL_`k)g_nAnb8E&GnzJDxPHc^>sN1_amjgC9&^lz2PV)O zuqHDQcW~2+ODtf;#?_nVu2{Wc?V>4DF1YBt%cjnq+BRI2*#X?V{SstleQPegtV!xL ztvz_ofol(%xaz>Q(+{4P2$5ChGi*C3eae(l!=_DbA?MVyCa#*k_MEoyqS2MDS$pC7 zXiXwSDm5BZTOSmwfIIK}jR7Vat=b`Mb$;&1fBB**iSQ*-Ru|F^9oxfK=2f7ZwS{jB z)2gcv*0fV!TLe`agQgYyY@u9g66jc9B^Gb&m9;6R^DD))3ZgCkPfzS`v!Df0P(_{X zRk<*7wpq%eR;5s2dj-v%6S+yRaOrunHyZwx@!u=szgNb8uZ;g*8UIyi$Bu)Y4)8k3 z@DGmv=Keo2{;R6xmGNI1H@-6ddu9BGYN!~!HT}Ob{@d@LH8$M8gMx~2W1Az;xh2Tz zL1js8&dFA0JF=bG3t3aXJl~u@ls}sfXjsy)q2bPkryH^^bGoc#)vca9bLuF^+B&N% zFzOhe0_%=&F7mvPwcoCCo~Cx&UYTckJM^i}v$;(g*5-Mr4LY~Z^K4$ri?;F%sNq-J zd6rc1w7onVD)`=ho;zD)qoX`eH-!9joF_{%)>)o8$l=R#ugssa>=pYt^XFIW=dak$ zGgcB_nLpL7NIRJxb($QjEpe83C~zJe)ZQgCrDqEF#&@OBm{>0@@;4IGkZBC-lTwFd zuJ;em_Tn1(8`J6kJyL4l^yPubKQ?ovb6Q%08J^8a`NwhXoAM9A&$97tio5Lp7CC$siBCGuJt+3hqo>k zwUX${EHg86@ik^5^+sT+qcSEcj|BCs;qQNE$IO! z-CA1IHe|$hCs!|E`*0QWUi^AeQlAv=2(n1)M+trS>kga}+LOQDB=%0!C~~#u%ds-A z4aIr=5o!;r9B<2WenQz}yf;Sv*EgW*K~AY=tNpe|56Y36(z0{chj#X+1Y6OU8l^(F zM33mRot2)sPMB3^b*8q4q)4K7i{0U@(o3bwd zrC0F3Kh&$2|05Fr2T;N&po0G+DRVDkI(NbUQBbYgHDvo#N3?S%|EB;wsl@-u*)Zrh zwQl~;V&OmdKLLt05uOR=;}T8S3ec&WnH@-d)7UmKA1tP4^Vks3llsSk*Z5AML-N%c z(!CFmeG~tCao=+f_^+(X|GqpwEz4(PLtXMO|C_RrY%3U(@{iz)Kf|H@#5(yug`Q*o z9{~I)Xtxh|ccZ*1P;pEh?e~exkc~RsOi_0A^MAj@{}cIc(m~n5*-6>q@Z*$hHnMnN zxwv*i=VvEEw*#|dslOpRxq|-(WcBlZ4gB8#^o8*MvJ(Gam7UXWt>uIfP-_g-9}53R z133oyZAkp6m;Yms)`4u7X~_15YX$#@Q${`dZyw{FCbsVs{6Ca0BP~h%pOuw1o|KVo zBearDIfqksGnk(Q|IeZghfw#*?6^Al-wbRu|J~|SFaOWV-kNQO_9teyw($RK_<#K# z@&9hdYBy46!T;;&i+5#i5%0|1lluRUvyWxF*@ARo_L0Q@577Vjl>bvI_?FuXFcw;{RowDt1%$`NaRL zvX5qO*(3fx1OM-%|Lx#USMWdXI>zCwY;is(Z^}>1j>vzL{WkUgK6&up5qW2BM0Nx% zxBp#~on7jGhh?wZBly#{$}KnCr9@61+1zbotPf8Wfes86BI}z6{!dilzbOAfUHZc+$|L;l}m-v)v zApg2EQs@T0g{%}cn5)PsRDI6*M%P3E$89l(kfL1}2}yscC7m0{=j_CGIx|tG*^rtl z37!RqOtHisq&bJTJ#xpYJaev41a+A?S2_KLpvwxc_Ly;5xSrtYci z90=zL%8LBVxDyBGZNk1Br&LP6C{sEr9idN5i(c$~q5X`FJdw+k0-hi)a+mXkhA~%! zgf`?~$bIBZzQ9HML;FMYWRaoAXSbJT_tun5@5GQ+}lHHZCb7bok zW3d%S=_e)ZFGa{+Vyg>%q~zPLtRZYx_7vM>t(I#3J$JSGUmKMDO6@p+Uuem4xzWpd zq%>nI)5Tudh+n!%Z8Kzx3;l09!iD}1OM6IBDWNV;yP4LWeqb>W8VrR71Nf;62XL=$ zlFog}mlHD}QBa#vAK->ihjvcq|DpfQ)t!{k|AT?+&0V4Y2T`heY%uj{;p@x2*0a$6 zeSz9jH;A&jg0*@vK7ayE4ljOpDb2!@xK6{{XPDlpd6)4(?C- z(9|-0;rAl7KY!h5c^`iLuzqN1+>4mu-0wO4M?kkx(4m1cT(yuky;J=;Ws7TX%I}_H z%r%&Kf^|D%_O+F={vSoo!K965<}o7Sx)**Q?gmlEV9FTH)t)+nTKXq`+IQ9eL#Sss zxqPd4Pn|u|c1uHhqkT{h&N#(^rAmSjlTw~Qz`bZ_)_Yq3=A zm7#yF!Sbxza`x1TwKA-)HuE{F1ca_r%QzMghtQHacRh*oDXrcL?Q3pR)a`0m^^(u; z2GaG#SluR`G4^oO66<2-30)yC_S6joT7Bv0L(Ju-G*OBgkk20cEVn;D`&Xg=?e~NE z3yZBiwl9)y{~SnLq=NcJDT)3$fV}o`+o7(|-e~{*NA>>*O30D(LjMn^+>yxQNHFL_ ze4+nGg1fq85IsRHrA%w19tvLeXDQng42L4!;@3b(+0V$OcG!zJ_5X;3x%z(qd9?Zu zPIWiXn}m2dZUjJ;YXt)-v#kFIQFGaOaI5Q-8Mygu(Akd*7y3WeKa04br9dMXb^+&+ zU_6F82Jx41uT%d^n>}@v`hPN%oem8`|2N_9gH3TCYUswb(EsD%*A#N?4JFn8ORCzfcn-K`d{w$Ab!vF{|szSq5r2)qW!nf z|C70^)c=#fyNP<|A`4@=&SVw04;nA@|42duNVSwg|4$`-D7O7ZRu^XT8^t>FXl(ma zsbvWFL&&`^?V3(}6Rn+Q@bj@9OaH-?zb{nEv;DFK;M$wIL;ssg{XY-9 z_Gg`86zvH8KMsucC+A#nIsp0D4;h;e>xxf=jc%_;uA9TzauKOQa{p*d6fE4eXFKdqdFSs!cQGm=zr&0j!L^yl4*^l zTxv5%B0hgzDN*M8lhd-*|CY67qlq6v?UTqen7-K^i5f+^`hOBR?X4q$9ztu?|HF~GuB6##)dZs` zQCp?@e>^G5kgFHnQ@MLe{{@tuBky}t_uiCI=>LVZM*Tktd^6;CAvH`TZV-|@m7n^5 zCJ;mE9cBGLgOmlxy!wAG@S*?bf~6FmKnRya2a9XyAb(B6(^%#8h|M9%u+>PrY@X7Ii=>J8eg#JGksa{H6_5VC{ z$>DIZe|8jnsMP-pz*zk+Uyo0+Gz(jOU+x`W907NG5dV+p|FhwFrT#yQyU_m!K=q^G zwEF*axLoM}mDv)c>u7lAilzGhbTAD4znHjlNIx<=mzGV+F5owceM6&(J%_X**_r&# zMsiO;o33KzXn1yh>fd`t{}HUXjG}}l*0APL+l5eJDlgfq|2HQ6|Eenee>`+t55+Er za;JgAQn=HdRkv=$sQ;H|SJ0MP{l9{g!_oi8BR%J{I(8wix32^0Q24frzkfvkt5ei# z&LGBtT?5y${vQTb{or>Gepwlkj&c@6&mK0Z& zecHu%LM^Axu>L4(Qf|HJtkhF|Faec*Hx5;K*b`oD?VrzTxz3nr2`^#5$+c|84Y zB>i+OIr_q<(Li*e1%tpVc9g{Ue>yShe`jq|=s9EQ!2`(e7|FHw(Er0p*;5ze|3d#C zf()tuXH(m&DD^1h<0$Z%heV7;nwEn7QsRfu%a0?^U{()jBSD9gz5tAlBd7ZRFz~lW z?+4yXpuh~$2BQ&1pw$ki#4)5apl!yJqIMg~XhJ>gcyQ0$0{UE@y_%M*{}&^_uA?nS z#zX&~OV7%X)P>+t=>PMO=A)40naKaK$a3iaMM(21ZV~lYF87uLFZ{7vMFQ!jAvff$apS zy{;5j=>OM1=gHaDHueAIq+IB|4)Ylh5o-3=~4f$pv1da58i;x6yyH|=%?2Jw-8NwFZ`YW zeNLjjh3HWA|4RPu<+rDh0B)b``Z_c(LU!#c){r?2ges=cm>@!LKf0nkrJpKO}`s>~FvEA$) zQ2#%feIWZK@_AKB|9_62^(LsfB|Rmcgjegq^|!3De;xV%Z1yOr--7q*{}0n9_5Xvc z0^bkDZ%gC<`?BxR2mUSlIAwnlEWb)E>i=)iPd<_K|BY$<|HkYcdrE%tx7PoQ(F-2n z;+UkY|Mw+s2EA}Dy5c}m8tKobx@Tw%vNjDIhS7V~O*7EyQ<0JWX?~^tHP`^%~Q4Ez(Qt*rm&!<7-l zos;zcabSBea(@gE`=WOaqrV)Pw2J!w05~^@eo^TE6VbD0B6};6{y(Zk|2L!g_S6jo zw?0W*jzUY8_5TG(z?$q1a0&f?J$bgm-(mdJ(>G-Aqdk@Se=EK3ee~eVk&VL`f!tW3 z|KC90xFCBEDTV%bzeDK%H-d8L|24?cp1MN+za9OuH*&j^{WB+W{V}@7@&DJ7{{Q#v zL)k<0+1~Wix!E`PJ(4|uUQ+*mkM{V~y$@;rcJ_TF=$rJ~1L#GS`u{p;{SNj;oIr26 zjFi{YU&pdX;#T^F`u{St&j+Y+PhB%T=&Jw?&V}5Oz`sa8dnS7xGnwTo~CtaG_WD*pJhmMwf@<}hUK30iF!a=JM?l|H*7`;R0) zA3#>_rH|c<7TwNs^cJZ0$Lt=Y{77iNffnA&IACo`eE`b7m*?wituD55Os(5}~g(i4^lApUl)S4dX9O0TA#q;aOXpNAc!}DKc_Ri06 zFkNf;c@7-E#BA&x+41@Qx$<*BuKYX?UT?~ep(o!06&u(Swl@DVw3wQY&(F-u^0O$v zAsdwY{L1oi@MBTlD<7JDmwZk6eWcW&*XgYQ0Te4kaTno8E611bjVt1`9v zQ2fO{1M@eepI71ai#(B9q!j6v(%Nb9GpDNKjH1_}$HCjU486P_h%wxLw zYF*b95h>;~m#b0T2)QN}77nd&vDYAFN%4V^dlbYg+SYn~%yL{sj21*oT*1>7ct+Uz zf@<1Y!&R0S*p(7mykdWbJ5qX3f;Qi<@@VUH)hu>niD9v_=W3emu{Lpc&0FiTD_gCd z<+u;W_Z74m2UWG_YEufXxXy1qT8v{AJ$9KzOZ%i0YYJ*q*5R6+f36Gr7wemr;eH3# zzrv!eO~ABx14xUsc`eViy?)@K)wgeD(J35!x2*;Djgj(lHh3D84Q|NK*mn|?ElW_y zQ*8xNQo;YAPLvSzwFV_5IB#w#Cgp=pLc}f)dDYsv0xDOmp;!%dzeVshq*X2mYaPM! zC`lR$E9HzSC}6I_#d?_Q2dR$r%-xsn?Am~M(Og=<~5DN2slp{f1>z!dWDtlqa~q_is?T32IbTlsf& z(iL3SB>JUzSEU^9)jHR8%kr;vO{kE6YgMk5e{K1$kPZSH^F$q5Y(}IMZC!22zxlP$ zxdtMXI~5v%Q2w=dx%MY5hNZO8Tn)Q^67uibUqA9F|E>2INMTEg6@S|%#v!%tYI7Z> zkbmh^$bWFz9xKlZ&Da`$OHy;V*T6pL%7AjGFRZKYYK_oV)qJh5Rdn z#hP=-e@JB?ak5??_uoo{8j{-<=R;grz+golz>84CFyK>2DT zEduUxa$i*JHV{Gya}73cgTs^I%|L2UHYbzUvHd8@bzM~XS1Tz0N^T#h;aZ+|zIE4y zoD<1Enw-kNE2_256>N7*^kB|EoL>g@7xLGQ_`z6(2Eer@{oP z{(z8w*Uf8Pf69s;JU3ecF3SI*CHbGltfY|tS(Gu4yV>L~%l|w$oRz53w*1eA7JC78 z8f|k8>S*ZY%KTo`k}==PnXSDF`{#koVNYas(G6eOJdybQXz>Y2{*NTCZTX+itoJNR zDaJq3S+81NlK)eobB=XvES9Z9pz%tu2>D-1ovZ0Pa@WsMl40@|JmeK{!f9v{g|2dqW;$MujcW|?ks);*bPtm zO8Ive+g`*DL`sx@cdhl|s)UY$!^-~<%6A`)ddg?B@>T7G8bUA4krU;Ae3Hwu{Ewuj z@mMW-Q1cY>g#1q+SIGa~q`Q+O5=c9U5>QT~@Oe>xud^ex20k&%%9DNxRx7W;BP z1-^&;?@QjXNYnHr{|6;bPfhYawYqTbPC(8V!M7gFHkVWWB1&1$UpMTy%6~JZoX+2c z;JFSg*21O5Q0G);!}EYX4x3I_B(Dcjc5xf>e;StKkpHWIKARf*Vii;WpFj_C9pi$8 z(-qA4UPmb8|GX5}lbEvnpIqt(DXHahJ-lC^Iw_r)v z{(Ua~CaA6azZFS40n0@{;+6kP+Nhyc{%^rv|LGR_e-(zaW%&%K!zd;!blGi}Jf8m&7#J_t$QA4ypRk0*eCPx9`c#nbBp{R z0S5E1gbk&x6G=ZU$^U`W+qV3lhuvxkD-_4m(wngx-;!NdlK(5A#LR3nHm%i^el3!a zv8u5zdDlaa*C+YE5&W*F#l4W>t7_2)w>!Y?$t3?fll*@WSmpnll=|Kz|4*^%A?%O9 z;`>-z7gOslY!dUb$4m162=EWXr#G}J|CiXV-i76t@lL)3`%cLJZTQN+cHFZ3_sR?T z|2FPf%O6^Ql$H&s9j~l}Ucq0&xHoITfi2`Dv#9 zOOV<^e%_SiXH$#(tW5HAZgt_@U6thL8dj42jnKtdzuu0W_wFP=Yp`e)@^d?!xB&^= zh`sScaC#nAuc5T+5Uv+Qe;urJjxQ4Z$ z92Ug8R-~vZt9;`e$lMJns<y~AT@sVb>h)DpQTnY=0b_88leud2{MGzmDdUYlf zxD>IGr~Rw*E3wh~W7*l!n>_!r2zb^Fhzf>TrDTZh3c|JI4r1TFf&n$DgiC z8XMR$ce^|Ok9K!nzI*4Lu{b{n3!8HiElOc?lP1n;w9bfu?}BLWDO%Tg4TUT!iMHDL znBjs3-bYN#gv?c>bym7^5q5z7Sj&k2Qy%tL`m(TUM?u;&CUK(~zHv=K7>0t;rOQuPe*s*>dNvz91KQKr*py1-9W})A^#&2#f2V2U4{HxiaR3* zP^R*~7wNt!RLogAt0642QeCP^Hr|fa zo*uR@EoE9Gl`y5Ne);bMoqN*ekbf-?T5)~zMO%edna~X(|GvxR8)nX>>yuCE?|Uxp z$Q(h*%D+4wPRYKp;z>}$lKhXPK11%r>qlzXusWmB2*%FJzw<=xA0hvvnU942FXZ1H zgTA%VMD0Tv*ZQ_qJx>7BzuYefUoW zCgk7U+d~-BhWu-n7{l0S06*=C)$+eDG}Wrrxf{snT=}0&8RKY4rTk9;Pi-dqFqd#H zIjKtio%wX`Lc6&m-&LAe0g&d6;GaVwowhLLUyY-!%v^gW|DIK)KG057$iMslhf=bq ziYf7)%cK1J){T4q3w@MOX!oN0kD=vSJ*7mY{A-u3p1la{*MK_1DH?G0e)dg{`W(EmokE$jGSidhzR*VhIw6m z_!siOj5+SH;C6nJ|M|@7`cY~j|HmPnJ|A;vcnsFK3*m5m@_#IIgu`0oe?^l2Gbo`e zGlx}BWj!JlVEnTDAA>!}T~qs(3+W&<5DSI!ey!Miqs}v#yJyI%@_zw! zE~%$@uzQd))aw@_pHrD#-=F0FW-KQCnW6571ihz5{?DSV$FVc09``ovd+PrOO7j0@ z?lw^3zq3#D1a_zm;CBtXQr-_oFCt&a|JUJl{qp|^c9qFsej66B9az4;0e#;l08b{?DL=~p zv9wjo?Y{7EQIdamNR{RPj3oankkSLGe-QosD5!O8J>(}}A^)e->yKuS&oynx|20Ye z*CMUM;q7h6|M_*|ul(O!lK*>cJ z{C^k=&QEFSN3g5q*km3ddna;KPyY}a~u}9aile2 z>k0X}n3fz(OO&70b<)2lIgbTf<>wZtqx`%9o_rK5`XKC_ms0Z?^uhDt!aVFs`(e+! zYY*k;Iq-ju{=1wrhNtIy=U<1nAFk4$%FhR|{r@W*IR=~KeC&ty>CYd5*`3&`q|ZB3 z|5}MIxR?I*wM3sgOZ2&y7XGS&KF?8CJ+7e7@1f60`6Jlh8nT1(LAmt#W_E0TDf`~f zVBg=~`J3{2*;%>tIX}05_08)kUyDUpW+Eg^5mUhX1PyzEHiNh;a);f(IOk4UpR@oN z3KzBoXJKI<2pd(LLl8ME$+2MAuFR#4BP>SFaGVYMGsV?Zb8F9!@uMsCzQJFdK;S6E z8JQzFotVY@DUJbbS>RguMf)w?vW&O(2p99gXumVanCFF+jcnv|Y+Km4#Lk+FlW&K4#;olhPKu{JyU(HAepd_~m3eBc?T`Hzju>=~v!?+y4roW+;}}m&;(1cE z-<=I}h$-4{udQzXOf=DcJTs#GW3wi5%;YzlpLoQsfS|j(9{Pc;){%1iogMoIo~x-j zbnQaOb4GO0e&?ILz#`f|irC31)z$X-+_|!9`}d)ANBZut7@u;?1UKJ_^W5~q2~A@3 z(>*~~w*LV1>Tq(LM*ELLJ08{2{u9t@t9b6({zKu#g_N{E6liYYzwO`H(*854{~+3b z5bqG_%I)`rlfA&KA5RZYI&n-D{4ckEHtnB5duCO&e?FMcteC&*tHb0&V}-dH#HWv1M~MX|G!T*z}^ID!<^T7Xo;BNb0P5WQVI70Wqn)ZK+_Fuyc z=3PAHb&dIctX2&J-$D5(R&D;5_XuqNj*|TU5c$7`r}|%6qdP2Lkx$M)#Ixx{^6pIV z?kZSEt%tFH;KGFeaZut7w7B4(_^;u<2b2^4&(gM=S^3+T;KhGJF8+Jxhp<=qORP}! z&ZqMR!tmS-U#0xtQ2rB?|4YU_qv7)F*(+U?|9N^}W%<8PF53qHF2c02Wz}_Y1whNmD=0Y4A0qdcW-^|w?1>b z2Q2h>tZukhw{shHJXM2h(m$TB(zCu51|f@mi^0F(q?)Nb${u8*L^3V+WbfPoM7Y zNZS+s_eV#%H_bUx@V{?q4A4;v+|lOvVi@`;_^*C<%pw0fw;@R}WzeycYeg}>h#l(n zSlHcV8vKu)d#(h@3r8vJALt16lveQHv60_4iIeNJLTdHwod1q#g8!a__2O$H1hzColMaD&wrxjD7|(3OyVCpA9`v=@j16q1>%Gn%u5cI+v0EWB5}Ob>s8Qi6l3ZA7*o#e44jc}!T;5ivldIo z8Swu|Fu#OSFYXk6Ig;jlYXonKoyoqg;QzHy#q$X|=l>Ph8jr+waR>YUF2EXcKXkv9 zG3+|{|K_yss$&!i{@=|G8~3EmVcZ%0|AX-VfsTPmeG*Ga@c(P@|34D{zs`HY!T+yz z3cnv(X0J3ZotgMQzlHyfpgZUPsf;%dE%ARb{6Cx7&B3Yv`o|KA7yUrW8OVMkJ#|DVA=cnK>PKj^gn<;+!fU=jLo1^++BjN!J# z|8H~(KPeCXAC*tcEBQYH`J>S7MRx5;|FQXQT0Sf9olE~;V@>VMJ)H1&-Vyk}2=~+wpmFZs zv4pS!m7yaPyIRV7mdfdlMJ&~El)nO-B8T>%*n_0KMr%>Evqio~7w5&b{RA#7VYZ^S zd~H>QeXOnaM{2z3~%l6l{zS) z)4~~#qix$C_vJiO()dOGNBe6vsO|TykQr&NzfT+OcN{YvEo%G6GY+hE<@RfjtQ}#; z>AH@-Z2#bP+CPr=k45t~wt7O3=XubT=dN!ZHGt*#n(7yF@BZzPJb7)u_m%EswDw*+ z#pcj{*Fu+8CK6s+YX3@}maDNh)$;#fp5a5$DYl>evaQ-b0PH;dPyRbU3M*W>5>MoD zBtJQ8;%{)PbkBjB#~8!6Mr{94WzZBF&uU&*a5$S14xs&E1uJK=z1nlmPwhXoRr~Kx z?Z2Va{v=|8L;G*Ql6MK?!#ir~kM@6`{n*j|FV&>m{=c=f{}-*=e|9ea7qP}A z{|{i7ceUG)@IMKQ*97W+4P&lqw~=+1drJ5}1pXhXPG%>x`2Ujg71pzY^53oSkMh4o z`5&bG-?u7%-@GXQ*=$4Jy8N2zO1Em-_$!_r>S=$)eG!WIa_)$ayhU08Q!cT9j+CP8 zT0crLZ`qa0Fr@V+d~?JTuw0wE&~&fm*tjq2NuMeHnWM-Z&zZkFw>J?IpkrtpR-+cab<}qhjlJvtyRoDwHSscBORgu8S5&|~b5l{t|mRvZk zZ?W^xvMeWlQExmSeP%}aWejbLV|Sl41(mdUX?+YQ4z5x7i`{?GF7x>Ob%&!d<|r(c z;#}>tVQG!h3FkAd7+n~v)ysAn7vl|SSIpas-M2!EY2+3|pAKqLOZBc8HCUq1AqC~9 zUtrc6Kl8ee(h}m0W6Led)H-L|tVb&O=h~ljNW0k8DTJd2=@6VQEPq-GSQy_FYg<>u>PdvSO9X7E4)Aht$sKJCNe8%|+~`sAC!N zjUCv*PfN62=8)F5z#YXg8gpgO_DcO2A4%sA7Nv%?MtjMSYSS+}OH_(1L&=LC80*S~@8tW71!v&VQ;nnSa$TQLjM^XoDGgfIZ8)RF0N#0agHHWNDI=lir}{pY#Yp5Gli`z!TdA8M5HwzAMe1!r5+&)!++Kj~pl?GK## z!m|qs{TIDeI>Z~wa>^aJzP}#&&r`VLop+_h9xM%wb9KU;L%H)*aNk9Vb!}I|gCp(n zSIcy@{&W9!=s&;Y8~QKa5%8^Hoja;S|9LOI(Vo5~dysGZ%eAupi&>QTsk?j|z&1G7 zk#hYKmIT{yan^YcAVK8*iMWH{jY8=1LI-L8^e|r({ zbJgAPro>(ccW8KOY+3(#O14tv=@D77S+_^OLjT2%6?K;y#9k3Uukj>TqN7KKo(bKf zY`elz{Or-ubJa@9qazThX}_=^TV9lH?+%R~8my4QN-~Ov@X>e6`cDoio2FTsIh3m6 z=^K2vM4u4q9i`Yc8^;*Vg6;3xC_>-(Y>%g3lofr}bvDZgZPONh#VUex#j^ejoe_In z+;tkKH+ZhLXEC_eU+6!3P~aksT$P9uL3~p|4dio8eprwADtY!SG4k6N_7C^tw8!63 zq^SSg1#d44{pXt&?v;;oVAKeHH^hDMzFDL7pwNFxmMb6b{OL!Y!APk6E8Yt6d&Pdk zLmZV?OOV>0EIt^C^a~y0D+P3MO~KN|cMg;ucjddgCB}dD(5?wqJ>dG0+RryB#&9k4 z-zaK|mWPd7`@Y<>71jFBbuXnYPO&KTpC{xiM?$xU-&p48O3qmFis?SoIFYbtkWZqW ziz>%Y0_UdxNl_Y0(wU&RRh=RS1TaVw4-V&?expvJxF1{N7jT* zq#M=?_v<+KUqnoy|0a;jQq+HPA@tu=N}ULH<7x90q+|jRo&w{!*E6~6PFZ5i>4ojm z&vzV^aAnrM7|%rCi;MHb)h+4{zbs`Rbbo&6KSvgRoyUCY>(GI&4!Oc)Zw>wDK7XIW z@m{81yzm`9%U9pH6VCTF%~MEW3YIRuQKhw1UyGd21a*LNJA@J(fq3o|Cz#S!+fi5* zeVf2lPqmI`-zdfQ>3{Z@=$sR;e2?M>$!K+3yc-WZaegRYaB$F*wppZn!pKO4{8 zaB33gZmGw328~uQ?RCD*rE87fe)O%$Ko3A7{07b>?#3Zy`(WQH>%W<_b0(>tzaXvy zs9_vdpuOoUlfZB~v3?tPCK9Lqb01w#N+|T-6lxg>v?cge7QZMn7%BAhpo~&{KSS3V zzr!hO8u=FjtNxn-?bUSCkm!SHS*89vfOXq3SnV3X-#vtj!Ei>RaiRbArzCs!1o-Xv z&pXF1)%s89JoU(_l%oEd&@O&s*?%>Uw)({#d!FBTm`K>`C_(*q5^)n*VVnXc>c8WOI~vOQy`Fzm{~beFF%IZV z|D8lW*P{#lcN+I){dWr1Qk^I5XW0_)vj>*--(ld|p7Yd_Wzg)^tkxC!Z*9_lt0}?n zPV^vUI&?Uj71qN_`fnvx(nZANSTG&`tt8hnY^{4yx2OE5|4zZaJe$>Y^`Cn%Pa{_o z_CWRDM&MV%i_m}Tu|>Bhe?GN+doA>z@6EbfcL=zR<~IbKeOJlv(r8ci#3y@Ad`U+c z>zDGmcQ(eGq5s^0s{V7dp#IYuAK&NdLQZ#4^apMf@jiKC{2&Ee_m9EkQzz*6LOvW( z_%s^N&-1|4FzP?wms9`wH79Yj*ZE#srT+5?Z0l@+`p@qsRq8*j^%H;(-m3p5lisoZ zJCa`L*Hb))syn^D(0_BOX-dLQ{dX`WEr1`P|E3}3>Oc3h>_=aE6=ig#4Cev9zq22A zeg$eecVk&GKA4tP>%U`Z=fU)(iH&&4Q9OOy;cM%YWg2_-~jzHr4zR9sA{kI00JOaKSi>!@dE%Q`LIF-^p zLFytT^-{_^ffCQ`ME_kz`DOigJQPs>ZNQShF7>qwD7!1M2e59f{`1>3o|vuv+k_Qd z4b}{8yD);-Na!diat2&JCG9a)|D8{px{xxIUmv~>;8!JHOAmVurHJ3UcIkHot(!+L zyCUhob9u93Wzv6lu&#bJ)EGxEy_B89_kiyi>~KAt*v(Kk^xwsldoQp@aN^3byr=SE zr0;#KOq@dt4#V%s-ry6!=SX0-vTib&+&#(rR(kf;Q2#2h^=W)nyZAZ&yB6w{$A532 zmG%x#D}N1F$IhYuJkdp09{=6OohK@V{`-7swc*|HzHR;Y0P**+f^j8&q5nK>{$}pm zcGp9%M`_)EvWr*!cQq?BKZSPJv6tgE-Y`3vwBNx0(0`9Wm-{JyC3!;seKqO7XUO$v zmHxXv>A!n<dC#x>&U{h=w_nvLjR2~>A&$%+&w=F;O0K$ z?2BIZTQdhjd-b33q50xkNlCxj(ibY}yZ_#A45|O@S2Lj6DU`hg9Myk^g1P$dXlUoz zbW6Zq{kJ%c{}w_gPdiipElB$B^rZiM<_w_RLEzShnjE_v4^2Y<9Y9Hafoc!GBazk6 zf7emd9D2kko<@!qRwE@72^acrYmNR}PCI-*^3CYKw;~%ivYY7~dciU5%;?Jgn2Xux zy?{Q_%zEJrB>5!T==g6HI!66>6TRyFSrhne>OlYfgnVCT&yo7?-;@5k4VvGR^xs2C z|Gk!eqW*g?Z+|JrTa*6#DzttV((nxLQGJZ}zC!G&q?RW* zv+5{*wT{+pEl ziFe2Tj{ZA?{r$(KmCXgU4?XAp8D^(NSEh;UW8>;fx2--Gj`*?op>BQN+nIbY09x`ElL`I}kyU!8v+x}E}E zKQDCdQ&e|}WHfqEx%=A8Upowr9n$Xjx*1jPtDLPdPXenWzZ ztMG-rxMQets*nK{w&O0`X%~4p&QVU-`VH0Rv`5B@oK{rr$F2nhwdyOuwQTX#-ra?8 zV+z*?>nJL)F4mvIo~^y6UT2GAO;@X3ynz!`t+#|CU+e=ApZe*i{XSN_Tobbd?P1cO zKBwKzRam*;DtOSp{`L#2rA*sYyk{!~w4BxFT)Wna9&2=A?RO2QekTWo^UVQez_FTk zh5DTDo4U5G-Cdhs;8B13m3YT++QsFBEpc7(5q-?_G55v|w7 zYMf{DX!Z0|T~DE}zx`SYe7m?e&pr2nyW+Da{PzSPzuH*I|Blw{YTKn<*Odrukimbg z7PY$`YoW^bV}bJ>4AY_l?VWItux&jqka5ezGU6Ypc;N^KzW+@Z>2^`>xmd zuJAOdH-?dqYaIg!`JLf<-4MoEt`>D+E>Q5_)sTAKEav!q7~KT_CsE2M<}nlN1!ttH zJ;)Q^U16C7H{BCkfB!G@fA3^(${AhGVxCv88_OI_{!aso#V>>Z3z^IH#nvPLosr7_ z!_)k(UJT0lx-vs-Vvgcz*Y!FrE7MpJ8pD{+vwj9Jb2#W_@_#o>u|38xv{wU_WwYyf^Z_QlBQKJ|a2mjB7|Ju#!=l{`IHUHNb1Cjq1GpBfY{ND`!w=&v3j}dF|fBQeg|2yD6W70ZZ@P9j_?t8II-H_gHf5#s3 z|3YT*_Wy$aAK3%`f0?=Neei!HGo`DUV?PczALUxFo68tq{@;@N|GCWY4(2WL`uYF) z692!%OiKQLau50c~QZLV3V*V18D`F#uamBo* zfYGmoD907KBS*QE1hfYiAsvrdo`1#c!kJRJwjyl7k;{;I3P|sSF5*ltN-Lnlk5WzV z+&SYZW?t6iebi9ij~MktzQ8BKmDmTYGa#V@ufR6SbcR$e+uZ+LCoZ-l{w&}1CF5ex zU92}n+am0a5p$cjXpeI#BR??{0>uSIWeWOktf}inF+grCbggd+*+B z|E$mWdYv<7cVIb(jhU>w)QWZ*>s-J&w)rBD*cO-+Eei-|pXQ7?yjQU{uBajQz!_Vg zvsPQ>{K^)~8)vwIlkK+-TVbu{w)L^E&D}@Fh^;V@*N`(Db4L$%_7;s0hR%9JO5HVV-Nr>3&P2=oSNd5>{j*ys(ko%&?sc&fGkb#=M6Y$u z8@m?!kXtHF2sKhFL)+l#%wpFXDJ3^zaS{))3JFn{RAAUd0l^M%)FQ;?i zLjQ@eI|4%2n9u!P;w6V-znJ4JnM>^PXDb4mbCD`d+E~;H=lXK59{WzPr-? z`TEaVl^^$!y4%`)WugDv7Z=ti_iNiu-y8MYY3{7^JBaE8L(*J6Ehd`8>WExF`D0 zJ(EL#RsU%T^?PQXMI8FiQ0PCu=%=+~5V>N1ukYBZdu)e2xl;dGMo+Mbz3_gc&@-<+ zm&e%p=T`$M!B&o-=J*z#y;7<2n{xi#=dLumb4Lr36!%+(F=lelk9}nzIfUs82E(v# zh31QsBz1{9C zbU(K8=Jy(X%fc^CdZMA{Gy07MWi#|&SgA8$)heD@ZJTV1-*;1jmEC%sXZ4SxE-jy) zI_-L@`^2q(1owUiPW|V8>d=4kw^IN4uDU(5Qvdk|^axrR)GGAfIBGEGa7wG!b;GVR z9xOut`5msY#5BPPDOJ{g!^zc;n7wJqxGMc89zzpMq5q`z-f%+wH-yygSfA8?L&48I z;+`J)&vu@?=}tg*xQ?bZ`%tfzdv%@XJNj-zH8}e^X{FT1>VCbMg6xA5PPEk znt+%^z3yC+L!MPR2TNXmD6tRNO{6YQo%cJQbLlss|J={lL|*mZc=jiF`d44_&*X0k z_X|mLKWU-=782K&y+EU=YZ@5uiT?Aw0wrQHmN~y(ss1}K;XH!-X;5qsr4Io+rQdU0 zXH(bS@UGB*Gii@Iq3x&ctL{U-v2axVw=X;yfW37VYfMAgTYt*H=CkD|G5Lr@77EO>*>_(DH=-Z6x!!m6~=TY>^Z#ifL8yxi`}^Cn-%qi?UI+(wOQ1K{sy@dWdkyh2~ znki{AC7(%OIEIpXf$5e@C%H%-DnKMGx6n4bP4MlWy$9>IH2={~ZW63)1gcR(noE zGaLz)U0KZu{dXAkoJcLpNb~yv%g8NE=s!>2m``cyzth3>K;+>J+Iuv)mvLQOH-4w1 z6V!i8@w>4KqyD>y^@LZ!k+YKiV}}lOQva=`uCo3+os}Q;-x*-GnAMwQl(3q=DeUQ5 zPdTSj!U=F^F;~wjSq6=jf0$<2dkMKgW>OxmLUyEN&)O{`z3|1KtV8F|*%ha9;I{dYE$ABhAG zqlM?Qepc3hmy#=o8s}2iYX-(Oy`h!*&t5Qz_!;nRHFRHt{yU|l|4syx(0{Kc zXQBVDgbww((0|*JVE5#o1)s;#$|m-ps{h<~{aWY{`tNnwO43HNNA76WqoyHGXOK36 zJ;rZFf}4;~_2232Lfg!)vZ?g)6X4G3lK#64>2&;eGcEY%>%SY&f3E?9LG1T@M@j!( z4J}WnuJ=NjbI>-9|K1B9=Fp2yWj*U6^xylqU(XKk(0?bA`z`Fo-8237IwG<#VlKy)SIYR&42fg1wPani-K98Z7?%rel_fcB5o^K4R|6YT9 zucwSJ!YhBDWVQ2i=s$NMuVWAM8_*-Kqoxm}Z+SdG+P(ZeKu%%Y>pB++yOEMEYtesq z(~id}>0inH0M~o#?H=q!yoDa?4(rf=w)&Y?`tQo5|J=Da0Qnh$#4kkhzMb^nm)L#! zAo}l! z^uqY0^%s$r8e>LO7X9}<_Rszl{r6tZX)pBOHMB|ncN48p|2;~c zU(`*%e?@j3|M`AGS^xb3X}SeTxsm?xUzGJ`_L8gr9%O|(^xv=9$E*JPV2l3q zf4>0h@1XxagDifN7Wbe9AL5M%_1_(7{P&9fi}Bwp`Y%J4|G%yOTt_JW90$ao-78Oh z%xi=yeRI|4Ttm^)W`2F0F%b^G2&cr9x4@CeT44qiIx?!E=_2a-m++0&=&&67=C77>FAFZpg#vQA_uI5EMt)uue zZ2h*PZKvJKbl0n5ZB5Kwzp@Nt0&hz<)>gR+7gUQiOG{|a6|~oPMM4{_TB?NimL7Zp0b;4l1)gVgRn^NNr2F0=^#iG0TscUlzfg}+R#+KRKpoIB?IHueYYf%Tz$^^3Ak-o;e*sh-v59V*^YbM2GA-l+0a zx$~7bw5Gf&8EFG1@GvoyB6xMC}&T2*MakmH6LG` z`(u6iWeR?wLOrL=yPoR1M4Vk`X_fu6cI;8M9pBwnVfIE%3+;uR_bqs5knjJf?^WlVCI#Cs0ZSo87g+J6Dc znS;D|_n5z6%rC@bVEnDVti$iw@Lq~)GuQt4TNt?@{6bbu3-5TT?{4vq9q$3U_D>y@ z=X@@|&Xb2MX#c$XW#g(;*+1{5)Mo!I73ax#-;!U~$&~9A*J#1PN??%%8>x*vI zt@=gTKktk3H?DZEg-^@V{`rezO_3j;Smzt!>i%;+_SrA>psgA5W|(*EYFZkhJp8^+ zOXL~EOrNs4Ti>BWK!w zYlK=uPj6hGH$Yyr|3c(ch`FPNn0KN5w}-y&s6kuw3pF-|#+nw_{=1yr( z42Ns~rAhlAfnF?k?EiSo)QrR|T`x${E~bh7hil3nHlXZ(0xWH`*#9!f@Gik3Y2!g+ z|5Kp5EBc1NiNddp3<2#14IR)@)6qLM+y5x^UKYx;1d^wrU52B_dSiY{+5bw|>msrL z36A|Q7W-e0xuRYu#T?9$g)uKQvBvWA_okboshvHzLqziyZr^hr z$Q+Ay$$|x*E%v_-_J0@RHel|T_J1eZd5dQMeB-78=DSv5Ug;*xDsF&$O^et5uYoZX; z^OzIP!+X%%lJ?JE@-4=ZNB{pYT5BuFbqBQnEh+YY8QT6t98cGvF7*Eoiv3@RoH%tF42x_pV&xfAy__`d#byyJ2U zzDa)<-b;TB8is&&!&~at<6ZlA4`}}{B<=qN{B|Sl|3#GVTiE{wSnEpI?Ow6}SCjT1 zLm&Jm_WvQY{Pd6g|6gtYoPFRwb-h`+<=(+8Os8gym;?X0vpn3Zec_d*((ld>aTbfQ z2P5s~ujYx=GyJL!yy|66wJl6nS$@tLx#j0|XzdH<2l%9;x{_BjaGbwU*Y>r`bB2ZW zSLNWW7_VO3nV{O`)pObE3XJ0~UUBnkl2>O3--6Vyp84fm3v*M?{MD{s%@a~1_3=qp zmWXq0HDA+ubLA`!OU>&TmV$cK+!wEWYhTpt7iVbrJi2Os^}TIAQ(XJPc@54t@cBtK zf5odpUL!K5_Jvl?5dyWb@0gR?a(<`wg);}73sC*f=gIkeB>SJw57)k^{^zsZEH}rt zoE70L2e0D}c41lB|NIqb_CM!C)U|7EIdEo4Jx{ED8Hmq&vj6!^@4@I-{mpnP8T;QF6m-d6q3UlQdr zvb>gPg4l!UzjUNj{mXXX(cZ0)M_ZKpKkfgnknJh`-yAu0ldGIYxUxF<{%VIx~p-iMe$p`TBCO~ZZu$+%0;C$C!KiiqEJ z8;)`R!T0}}7|D0Wczy<+?OBVx2-@(H|ET}3#PyRp{%7MklK-UtPj~wNVLS~r6URUM ze-`@xL0ntZzMPAr|Au7$KMR@FxYn6>(Ea}qzOptO*JC{X`Q3oIxGMS(PX#@J-)_9G zcJ(Opc~1X7j3+?ukp5qZ?aMg+`E9h?mM_p+r=$P(;CYQF(ei8XKAVnt|tJcVP_w zaa_#%xXeZAP${TgQI4P0H3#qHxeG_qyaUT|y&BuQ*Gp~+Zka2e8|TWAaHTxQ}v8;RcXGfy?f;yqBett#a?+TuG%9KrGnPU@aqWeIqgK>aS%2oD-XP=sM3=JUtUqVrIpfA_o9gP%`*XZER(<_>=aTmhI4a@& zIdA@|{=9$0cYbm(cHz52mHPR-FMo%g-D0d=WjIdTBem# ze||eX6ZuqfenFnUAmXjR`?Y)K&R;iH_3w)MH-S9ga;cQhMNEm*pI@tQfb=aj3sm)2 zzc^73v&wu!gyR}F2iCs_X4HZh12hKd56|z-->pCAqg&#<%x}2&OiHtab+Oi5{~@Sv zPn=U!|4)$8dh0*NssAwa!XTs?j$zRpKFV62>QMR!dr|9(`fgH=7`VR#!#Z032 z2yBEWKeKRN84l}n>%T~=|9H%mErw3F{);ff?6wZ=zZC6q0@`RQ>R*m|=!KX!t>miy z$0NrXSZV+BJ-Hj0*`1Da;%3xr9`a)S*Wrv;DZd5vp9cLmqZIsN^luPT8<}@`P}t=c>1$y{WqZgXKMAo3Ukli{#W(i<<$RC%qPC+ z(f|K;{oR)0R_(hnh&ZUlmEC3s3&}Q&gRocY<+$qllA79q4tHT zIWpmFnp<){F~u(-@E5geTlmBdzkHyMAND`B@_r%nsJ;F9{&+o{qxkd-uNCcYQ;E=R|5In<|6>1lK#e;VH0s(n#v8c<@(*MWQCXQCB?EhKl|M3_ns{WshF=x%s zg}52_z|$C2`+o{Xdm`3y*Phadp z%XrNLKSUH=P)%!H1G$^9z5&^{u)Q7IYmu%cwwodIAojVv0b3rfd$E5k*0~;Ch}IVq zP_7gjv}o0)z0RtHb|C3h(7OrS7qH!h^;+z|g!MY?zl`;I?7xEbM(n?e?dw=?!Tx4! zZ^QO&tdp@WL%A^N8l_`+0P7y?ALlS`&v3%53+uu3&5#G{$}sEH*hxPgTTB2;UZ-Lo z>6jOO%tWPyj_3@;F;8x}GVXL0C%R8T`VSH3=!qVMeXdi~DteKh$eso{=x2UL6x&+c z80r2WS!7g>4&;{oh!Hpb;=0L3oMrLi)kH|`SvD>Y$np#7)o<9Sag(NpG;1C@v}NnI z?VQ3r4&h5tpQo^1hW%%-eHQB#Sf9rlL|h)$w^41hxv>#(^{@_xJo{oO;?RcDo{S%b zl@kc;hkLQYR>d}%=47O$?V{glvrH2miIp;xWk0ZAsmJMOq&mpOl!ifjp#Hd)XRX;r zwq=`GGlJPUb#n7KMAw$+1JHFLbUunTj{PUGJs&IUa1pjF+r^0AhO*s_74;>P_}1|Yv^}~Y7p?0R77RWsCUEJty zl;H`iZ$k7@Y`bH98Y^s^Q&Q1e4{ra!#bseo8r$~y{3w$rar9o4c{|qgQ1A6vVWrZB zXgg^)v<=%ziyz_1fV(hjEHGs=<$^H!BKRA~;}LA1Qgx9!ZNNV3R^67vb?;(XK3`f| zdb*vOzi~gx_AtuIeqD=wx6hqEWx0(2R=1CrB29&p9(GXO!s8WPXiLR7X>y?DW$1kk zEBeidJN3D`nyuTPtS`9}PR$z1MY|tMTAEdx{)do$4OY}qY#nwi$A%O3*fM$u2c55q zMy7uZakMp-iz{u=-LLEm%V(vf`>M*{3B6mOe=D}zussvonUG(N{j;%uJof*tZXY7-MF@KlKIXaGb=Krk2nU*W$ zsgG$`2I`mcP(F?o=~LtvLI&wwo=krt@>`6RWpV1m@<@H4i{+90S-xRNgQ2nLAByd0 zXGPq>F0euR5o9cft~eDO!Z>YMm^k7>>$KH>nT%xGY8KQn`W)h)$95-Ho|8KwjPtvU zP1<5R7~w*!W3X~)j#c6ij^-lV5L?;-(;&TY=HYU0dXABp9(hJFyyciFdJO z+&udP=Ww5m&hTNed^~b3OO9T6E&R8A_+LZD3!#4z*kWv#U^^FU2kg_H=VP1cghyhZ zE5cgbLGbF*iw-BhD@@f`aXws9pawHmOf+^)}08yj4hARH?h8h@D^;BVT%boW8A=VxQtif!{pj*8W{Yxj2+)Y-1}H*58JR}9LRQ(vD)R>vaKk` zITD^beHbhV=~WQ>Hi8eptsNKc4rF#d-o(9J6xn-i7T3aJ8WEv8cZ)#`&8(#&G_SYwsr5 zw!+#BYYXJTvO<@4E918c#2pW&7L*p}JvZdt(x0PkG3BT7L853=tl0?HtK5oCH=Lo; zM=LW#_88o_Z365r(a*5Q>npa!YOHJ*w$B5|`$4P|us;!7_C0Js%7Q+@2hY@4{6%bG z2jc5+9CFb|veh)2N~ZqeJQa;$mu-c5NxQYezSC~fc45TNMI8GF@ll4^rr64y2E!e& zMzCU`ey(y!TiFH*R{6`ZzSJFUhe=s!S1AX}&<=5IQUCI>~M8sQi;S{NNixNWnOapzDZbX~pDu2}2N? zC*`3LncYVw~e>TH=WTwx#sgFKl;k`bNd&{5IRxEAS+e;AfZW3*ZK52n}9prC|Xvb)C=}jj++R7c!Y&$nSJ2Tx^ke^*YC#z1dPG)*Wenwt?PMvy<8a8TJFRy-nupqxt{Z5^`78ZBw z-lL>vuikz7^&c>BkfT85i%ZI!plSQ<^sL(#4YzX332{Jgxpf&yr(S5UWJef)3G5dRxBq8h1ArsYrbWoL&l4coqJEy|SyyM{Bp z_{UR+otb9(0yvQT=|MmKWcqpik)D~A?a%NBGqbbOVX9d<`SlxdVAfEKU zsJL5IZBiao&kC67W?F_n-JhA35y;BQ3Z`eJXY-0CI|H?7(6DinR&*&W2-+Y$Jv{@7 zvN3v1$q{X3!`yIL6wJb-f^_WCXz2l5EoGsp%qDiT;Zr!*4K1w9{)ED}aGgCgC$!c#D5u>T|A?Hzv(rZ8^g1*Bh@9}^oL&QS3J2!285RA4{z+-Z!w>LmVa8{pBDJ11^#J)e_G(57Wk(H{%L`KTHv1+_@@Q_X@P%Q z;GY)wA8&z3dRX!dJ6l%)FZsE++n@>>Tm50#!?dj|_YMxrRwj$EmwVbY33J+>OF(V# zrh{4!Hl#Z3pvNj3M` zj*-fQR#goMtMp@F8!G*q&BBsOCb()$-wd{*(qAx8rI!h>YSJH$oP81>Fkel>Bwu^S zjH)Y`^#S_YYSjzrZ8Pl>7@%$Wd6yB>i*w7D8g{^cF~qI+nXIr>k_9e8GOHDISVbo? z#!4TKBf&~zOt&)`<4gZHvkIjD%#E3Lm4y83kQL^8XEVpAneOfL@z=Tm(!Mi~;O-UN zUCmtxbIQ#hNDFLG!5<_O-$h807Wf)*=>*n7MEeW>z;0k3cHd6>aXIqO=#LVo{WJ{G zM#dDBEbTYmBn@PA=Kk;8&*dw6M%ur*-!P*OZW*pD> zzq#Kl<3gt2$Ng~TD&}LD42;NpkmWNaFfQ|2M5S30n38!C#eL>oC|)G+z?@=Z2+G;;)H3QTt08JTrhn!4sA$nDI` zJMlNIq4@$f=Vr1k(^{C@v00y)V6yh+O9*Vt{DOfF5{P9+DAQ2_n=}6==_G-znLZY$ zi+M9-9?ZO(fv!@vc;-kZD>7e!=+j14DZEeGWr0SBY?!u*mCVRu>Z`eHWR$V&*RZ;Q zjB(t*p0&kWc7f9nmlj|L2HBx3cJ_1FVJy2+Vn23c@hfwIFAzvyAqjrs?nLaS&%&Ra z2cX>yRJC+-Q!e7`90SBu_J&O>>tKdEz!KOSHm=Nln_`(vWN%2U%$>ksUPyvlSLMx` zX_y6t5{j?P-Hl3_jlYFnd&7e(b7QEB*@VTjH|$uMhu7F!v1Im!tt<0RFwE8}uz6+P zJi~0G0(Y#;-GuaJI~BZlWo{W2b{j1!cCXAWWS*;MOE7wBZkWOCXGk!1YVJo2{&ckj z*PoVu6oXyN2bJ)t`FFy~%=zYPDtwv|+=Jq`6(Pk8ToieAw$ArkvjvF&TED zo6)n($BA7drd7Sd8kgXc2KvmOE{aeUxFOl5y(<`G}WVWgEH2Fpu-E zm6U;@VRn#_elmi&e7Gom%|k*OYGeq^H+|h}LfUzW1SMrZHzl+$V9VV#UQ!yv!z`we-pNfl%S{RG z+gPJ*r%1|NH{~Rz0dnAy$wnMzM3bfT>o{#mHl({3q ztg4aT5J5>f!A%MOF@UWSpDiidxhV%R%zcz=7i7@eL~1noIh1gzI&6IrmHuZm z`Ojz)rt$xo(Ih>%8K`RM=B9x-SUsc3T@{|u2ouL9sm*YBbsZR8bLKrbd&O zZ507$>ddly!%tRT{FgKQWc4Mi4L@08l}i3%_{mYHocCFJiA)YZ z&mf}nXH5hpho4uwh?NqQ9DZ`tDN?MTpfr`hNav_ibg`-unH-tYISXQ~1qDI7J~BSFMf$&01?lVC%7m%o?V3)xbHDxI$0x~Lnt+xa8oA7v$smh zLO11VrsT-_F*jv$Jo}oY9O0(if}k^={Z7afji~W#I!+83_8g6<@oWnrE4)PXmLOg# zm>kcJl9cP+lx+}n#${^YlvRyqJ4#ApoYN9~M^#dW-IU4k>`{_3>ZUAoQ=Z_aOpa$)Ny?a; z@))M%L3D|m657>x_Et$5cT=u*Q$FUVOpa$?la$7Ir<_~dlwZ0jljGUHC1tLg@@=N% zahmTAz>?$HwlV+r z+?0zDlvcUTO_?0eJ}xP9CpdMz(oOlgn=(0`{Yp}{b5lOel>6|9tJtJIo^7Z`k8bks zk;)m*77K}JM2%-h3yFG(sF;R$QIQ5?A;ytTg@mj(VB9a=CM4`7 zwT@?xp2_iS2#xHFXU{kSd10wKt-2FkZ>b4P%T!aI&OE1@+_cnmDV`SPbSWNY=5(p$ zOqZ&;OC;gMCn7oVi6=H^W8;$<*C$6p2-$N^(+bF(rjK*1c42n_A17DsqQ2batg78@ z5O)1r`R7Xhxe0&LHc!BrHe)h&tCro|gcpHu?l8m=p5ZpxJiW^uN~xA+ku8#ThSlW*x8LN;rJ zXD8pXAA~&UC8E~{U81*V%dZbJ5Igl8w;sYeLOof<|> zP=Cru?$h1eQGcGDe5Ws$lpWlZ6A;YeY>V&A4MGYv!n2d_tlNc@XoP1c-#O0+>E|V) z_g%zGt?YLXIp%i%@z{V2+vNwji(EVYos$vbTy9-T%~J-XD8pa_X#nM3nLxv z48bg(oqX55EF|P5Vu5=Q@0OKkC*RGy1p!-iQ@+k1tvUz!NJ{)z17}-&n_D6#!;ZTt z_qi#1xhe6p9Gq?O-FAeeOt>lAG58GfobIMXOY!XFyK}juG>#7=gc@*4SyHZXQ$jmu zTYPt2Cn>{j%9U=)``wh#&e;~5jW*-H)SSj zA$7-x5INi8dw@e))ZI<_2U2Enw#D~QZy|eKB1bUmI>yZd+Bnw zzNbEyIb_BCH+v0nMH+e9jp%I>)e9tu&6892O(G~HcVt|pw*%sf zY>r?SXIp%`ju#Tv2+vNwmsSXgdWkg3#fX>OE%}R_?x;r--z@3lZu(OZ%(@$A1AqG` zg*>Z~UkX7wyf0*zM()IE!Qb&$A+KuWJe=zMopMp`4Et@3!k(-M_3Rei(tC9M+Q{ykXNXV}m`J5#vzC*}g8ab{HNH<=VX4uxW zFgw8TOY7VPFXHc>5E9VHZ>(vLKZN9Hq+@fClDaa?tE-Xu13-Fq5z<&A8RI~DjSv#j z2)@o|_C-rr%Z}y);rj5TrkcBpLQ$8u_>z z$YFbg4AICREkOowYBa+>TqAeqfP^{InPHF9$jnh71B-=B(#Xl&;b0aQk{bDZFvw7jO*8Crjl56?WZ1nzmTJVuqh$C?LQdAm_XQv$z7!JG zNVmEmBP|&xo~@Bv8i5?%RLB~QEN=laszk^|8ac5w$mnrGHfp3PTG@ZZ2|}*X$TZr{ znAJjV)Cgx|{bR2Ya+^l}#&aG1aSsaFs*!J5>hZ4%xnCpawF8;(t&r^+nKudK$h0iB z^^+Rumkly8BxHw1);0z?s*jMDH1arGXVOF=uWRHB==M)87xJz~M)m@ka;}hsMy@LX zIr@4bpKD~!At1+W7xJx_h!1@W@!~yg`HK_eleCWGzLoUG^e~--;eP_btR3{B$EO8Z z|M2uMfkU#2uvZ!q5}h6eg?^SvCs3y6J+%#N{>eBHUv5A zFQsR`SC38Kc6NOnd9VYGT-OfdoI)W{jhsmzdhX#u;u;y!8|1v1LW~7oJvUL$`KKv8 z8hMMYbHPTXMj?GE+!+k(azfAA0F&LW~o= z0HTPffxe#Nimu%-a^h$g)mDaA2 zLG+axeLyGsrb_lpc+=9s_di8A{IzuguZZ z6WgTpoa7}}(uZDmztVHEm-HA1a{X?lM+% zY9_=u)k}V%%+0-o#5J;sKJ=CeLZYX6W$MsEHqTdjR(VM~`p{d?R(hgdlE?wMEvEEn zDwMTMo4t6SLPx5(Ctf=o^@Vw6@BQV>y(}gy<}oG$YYz89*q=*KpyAV z4jyd1SLO${PW*kPXM>kC$O3udSEc77FFA=m^vT@%Vh0*|r3B=u4nm?Adu2A#hdw<- zNca*D5g%HLc=4Wo`HLx?@1fWK+)_zzTNwL0-E{rIadZGLag|rbKN{riE01c$&IloKjhs&( z`tEcgp-tZ0f?Yx0TPY-}k$VP$ynmUHghtwQ2l-&Dknq*s+y>Bxez;ReOe4S1hkmq2 zh;fZq=2rU9#6BSrjcjTU@^M3W9-J37;-kHNQY<8Ntv9#hXgi;d782FS!pR_eW(i4X zq#zgMv#5}8%$wV29wnb&DI}(mUc*4XxL1gAomXZ>U63zd5)#qKOQ@s&t1pGbH8N}j z$k$e5)--gzH@AoAL%(S%B&v~_^r7FD2uWz zwGiV*uS^l*{Clqv64A&j^r1gKC?u|tdnSSW^s121P2Sw5_6GUaw?d*Cc@%N}pVOMK z4H6njKNRGbkdW}r-rTy?`w22`^GY@3kzkpV1w}N}nQqiJ7YmAO=u7%UpSf00 z=yq?0<#eQebF-kRhBgL)(#)p>B{cLFCi6JEEaUbgKpC zp@QNX%BcfX*X%DSw9T7goQ}1gIYm%ZL%Z7p)i;+2N@%Fb1fT}yIzi#Py%{d;2h`BK zRZvVrXVbYhGM^S?+~bw%m#{cBUR9y%K?@m_C+7t+BV zVipRDYUne1v1aBdK?x0=JOZe>IZIIZK5vGvv<3>9rwfW{h!f-f7Um{F#{FKYC&mFC zYCa$+qM>tX*e%Uh1;sUVG)vgZ{7z8l0dIyQ=m1-rfsojthQ4YC)W&QnD50SjCIPiI z4-*uA(3{~>`r3Bp(Sl+cdV{*!n@a^54|%1U)7y41FBBBf&~Uojj^=HG;u^Y@{8K@knjC<5wcP8Sr_P!oFH?&hh2Vj3DW5U7W_QBYh%XToCrCFVVX5*q5t zgQTbVk|1Ndw}eCTfO?r<2?}XwUolW`(}%W4y)?9XB2XWb-2%U$p)Ny!`kH+NMK!d$ z4^ThzC_ym|Wpx4SZ!QuP*U$-cyN8(<2uf(^8d$718303z4cmI4``fu zqM(q5PNUl$Z>|v(*3iv$fhL%@2#RRvuZBQJnokOfYUpmd-HGN0f?^u_if;EP^LIgU z4e=p5|0J^jDKHq+&^vUylg%!IjJUU6F}mF;=14&y4J~2`k2Yrt3Tvp8uJ9Ohm7s`* zO!n8Y=9Pk?8v2xOcdB`xpqPf%^aeW4+$|`sq3@{cc=H=U2@Ul;6sXipYa{*jgtuO$ zbh{C=g`kjzp6CTM&Fm*Atf5A9yVK3df+8A990D}MTr4Q+MdEhXB3>MBz;(NYbi1?6 z8$=-H3M@x3SVFfu+k8w=LPICf?andZ5fpmTsgg()(e2JPe-;$c&=el4Czy5G%8{U< zE1Ln$Gdl=MXlNJ@lKJLPL7}I-x{jsWU0_B8MKn~m8&J72$kGObcgun7fAVYYw#3JVa3F8LzHi z2LM%=y#z%xluZY^%sf(1Ohbp$?JhUVl`aiMDYe4nEn1AZp7rW_xj)cJ=8a01hQ`zF zo@_p@bZO}Kfk3C2?l~dd{nBbt|A#&0HLOIN@oiAKmV0W=BCW4Si3y zyUH9UD50T!i1SCyX@WvKyt+ox?VfI~6co|W^|Yun%*zGEG;}ZB?wRJ@f)W}!mTq^o z`J&SGyjRyHbh~GnUn*T1x^x)O*{0n=Y+gf;((RsOHWQT4P(dT0bIsm@LOZ>>z8(Q| zo;guaL_=m9p!3azN|%Q22moDRp09Li=tsKUHRer9*9%@qSwNSX8wEu)^bXzbW#&DCVj3!<+r8X;Nl-#Vztin*G`|uQ zddZ_p+^(;a<90K|?ZUU7dpHEHG8+Tn2^d%4d&mbLrk!mvdk9*jq04y~Uu}*Pv|dBI z>2|L%=Ly=Xp~0xdVUuSL?l>4$%B`M*(JZD^Qz9pzo zL(4-zH<&*O8mFOo%HT2{Vpe<$-L0dKS9S`HX%o0JnHS{wNq%;)0^CFo+GGGLs!uw-(y}cXq<+c9R+l+`KX{p8rnqzxX*lB(0UC`8x3^7`7c3R zH8hXC{D7H*_QFHY8Y*U$A2j*Z{`(<2n9ObE}~B8hQs7?SIUCLC{tW^`_@~-27b7ZVmN10w`{p zg;FmKZRO$cgxOS3?rYw9RTKa{Y4#LUsG%sV%>R_h*(>-B4V^>-c-mYbXpx5Qq4hpv zo-1g*hK3IUde*!_&{ho{)e`7A^D#lYHS{KjhC9r61nt#Oh)3n~=Fft1U-#B)NiNV% zvrZ8UU#Oug*p)As9R!Wj&~t5pc9}y3Ez;09SegGtGa_ic7m3?F1@Yo=^W`soL%Z%M z2<$dDh(O#GC_^x~I1lI*^A16gH=J?{+Jd_HUp1c-WW4D`UmOYan)!*Kn1+s_+kM^q zTTu8duT-ND&>LpMVm3rVL#>g{|EAeZQ1orD)NGzS-!jJt3cce+W(%OV&AEc&8hV}? zzGJQy6nWPxbx$3jcg<@B8Si<~`UybqnGXw!Y3N#Z@cZT)g2L~6rEWr9{U4Zn1tl~z zok#eGW>z;=Ir@QD>RYF@q!4iXg8(1b}qKbyx13V-938c(=ufk830otkq4JhMf0;c5h4*@;(h=wX+Z-n-p`i&Z;XZSopy-cYsYdMO z{pQ(%LO*%Ydrg51ix0uV4mH%e9gt~l7ZmxIS86WZu4TO?$oScV#O?lscyYMu^#Z>U z99AC!X;uKo3To>LypMFj(P$ihy46xpLPLXa;P?a9VS+-xIBG=dLOPlZ>u5m{4Q-tW zlxZy$6w}c3BZ0E43k4-Kl)?T8TDJ)b{p!_qULH`k^^Bm1hFb7|%&`)JVj6n215h37 zPeBO{9m7K_*Q$>z4P1=>=GE13Bv77JBq*Yx8N-3{touiIL-VtN8d~2gUH|s#n#G1{ zWM%Ybl_MIumaWm)Y9%P9p=apSnpgt_B{VcL1k}_zMo{PvudYN}phK(*rAtGP^2E^0 zTCa3zXxUhx=GN^>mxk6+SIBx+>H5>Ft3Lw%7S_jtA{w&jO%ApG5){+Wep+u!s{uLy zr+*Ed!-Kz-RV*mbTW_dHr50#Wcj%5&ZqF-GailSL)e`K!;i12uf&Z1>NodE3H3k8})gmEcRm9Y9T1(_o9ts zfCgIq1jRMfi{50AHCa$3%`5d4-R@v(u^=Pei%z7Y8Dgy!6w}Za>KbZo78DM6rB0^X z9cDcxD50S~hX4(?J`@zq@Je0Q6ljF?Z$Y6Gy!EZ1xQ1S*O;51W2e8VKT(8ufbh}4dhYB+CyyzzCnrQVG z6w}beFwjxf6hYy9uT&$t-AUFGK?x1jF9w=ytrHY2@Jd}nw>!nURZys|7yZeD=xFO{ zL2(UjpxZsh;!RT2tDaXXOt*Wi^@kv%z896zw@$U{p$<6sHS`YAaaN(Aa09Q@3Odl^ ztx0Loh~TU$cy&U?M|~c35siI_(-7X)&qhfjlEJA63wt) z6=XE=qNC|{XIkG0ifQOmy4^C1M-T3SH}y)*rrFH0S_(>N=s5b;+16o#qK9~;ZX%jv z9W5x-%!|g+N6odC3W{s!IieG+3k5}*d!;(lMCVzz2{J-n6ht5T=UdMRig}T^-2~#r z;rirn05b`+m~!h^5eT<%^4f`QkXI!Bg;pNA1%0ofa=P6`RwqHmp4M@KT1U6L#5z?_hz*RzFU9D^(e6@fqoAmUuH|UA!n#LLLPKNeO_o_N z2@1FJW@xZKmRny5ifL#ho!Sb^hwBsEt#0j=dXH}RB&)fgh=w-M?VfD)5fs%dO}c4Ls!!6 zMy>Y+8ST7Mm$0Euw|)~8(a?)@yJuMWL)aQ|4gG60(3w_eL812E44d=vus>4F!e)U1}9zgR#GcO6glKv$_Zh7kV?ih3Il?q@b9FPNdu2Xw4L46nUlo zYz1_MwMtM#L#ya^ue7cd6xUD%kL9bZ`virGy%|1Aw8`2nD5{}t9PM6heIqELp^xZx zud&i_NW=Sg^JX}dCVH*aLQqUYt>|`RRzE>TcaM~~-N}d-hpXOuz*pVQrQ5yUS|9=u zS70E5!F6=IH(2KiifO10591rH8w4dZ^cvmnP1a+ALOq-kNQOVr?cQv?BPgPw8|ij$ zv3^#%G&F{8ce7Pzg!H|Jo}nwe)#@N9RN~e3;h{jcSwjUyG}M6oak~`}6w^>&9zS~+)4ELQ>gm8)8fr%0dY83J>C({CL|d&dlr9YoqubqPah#8X zzn526!xlhyTZagWXy`S%-FvKFf?^ul#{Rn3I#N(VL$}lI-e;97UA?`!9)K(M-*26# zbZLm6C-*;K-KcbFsF-f|LF;j)OGAgX1A54MSLy2G)wQV!(8Ja*N|%P-W6M8c<>DlO z)4zsZqubqXbrh7)&>3N%N3CIkLVdluhSTjnW=#_m(a;dO-N&t!N|%Oq(e1{q%atw- z&868qVco5C_4Dd_ybaKk7SCWAc0@zvbh}SkUn*T1x|qK8Y0Dl(sf30yCILNTH4_x- z@6~lpL!f7^-hv_;`aJ{aIcuVzn1=S!?e4G^DqR{1!7urrx6W6(IHbhlmt*-C9$!1H zo0KjMvFH6SSbW?X{iUJv=yrEm?nlNF4PC`S!`qe*hZ(A@p|9v*-?5qtifSl8 zvw7F*BPgb!hv{J7vyKuJ*U(Hl*!QhPf)X0~i4OJy>jFW>AaCKbc{qG%-7F}ip)PFs zkE|yIg*6o6s4-!^FDRm+<~+nxK$|zNUly!n#6GSVKFqfxfiv6%^6XlbwLR zvR)Px)zIHK^zoY0*MediYJq0(e`ER4C>Zi;s5@Qdw^m3{LPLw`V865a3NnUx>va#M zzPBa`3Tfyk#QA@)P81Z@(AOcLz1A8*5e;1t2Kv#uMNm{j$J4?7WIZV;rlDi$VE<)( zASkY(Piav@Kn#!zp)-lT*5)#@TBq@lCuV1Khl3JPoJHXbRz zTQdbkG}M9)_TSbjK~W9ePY3&lb)}$~hH^83{28X*`A@=`d2#RWmlYRaIyO*H2hV~)OU)MfTka4(I*JnIP>e=Oj!WtUc6R5s@ zo}j3PrV%x;Ic!H8YUnl|s}1ePm99}v2$_t z09_htPY2r6?kLC@?bY=&kAy?)VS>UM`jI2lX7)5eQ4RgTQ*v{ArP8IL_X9v7`*Nl0 z2(PYf&460icPm{Q+Q5c7)P7Ov(on}yKrQVrl`ah>=v!OaHoO%4-59T~mNe1UHlH)g zu)`X9nk8&w_ZAe@(CIlqZS9GI;u<=EXPS2QLZxf0SJyK%w)XbAAYvodm@- zw2c;3Xb%@;jQ8qlkAT0(o-Qb?q26@X#rCO6mxg|z+wEp=RJt@&)E=n2&DVUVZWqwX(*3|U1EQwbZO`gj0yccZQo>O7}rn-HdHUWxgg_6udZP&fO^|~1cfzJ z!iMT&A0;TNp?*Bm^tBf$T^jnGUD?mRK${6_gW zigQ?sz?*F9!|jP8u+F7Ko*pC{<*k_4A!WB50L28Jl2>e71W9|Dz zATr5ms`DA7hF4qx_lpz3snl?!{e=j`U4cg!qz3C~r_xD*oDmS1Xg37FVKCXz@U5$% zn=9bHj~!e|4O8rqA`o{44q=cQW~K;mBE^5SeXq6{^n&cZm+gYwT z_Dv#?a0O0ckmZV}2prG0ool}-0)@voHNOqP;99ogJo`sM5f?G9U^kX)z8yT4)!*tO zN=doeB3{asd_=wj&2W+3Uj!1aKpulE*OU~2quN2>M7vxB0>?V#8iZhw51#m!*yjlf zxrliMSJB}uwQm$O!bOylay^b6DOd6t(ohKmR@iTdK*SZel|hzkZ;HU-)NqoWHWexC z*i@%n?;>6B)}BD8*ewJZ$2o|31@EEMO1qz+@bO-$!93lbW=~cbx=5t{Y7Vr@UMwh4 z>XDM#tVO)kCi!UAY>wT|v~N&qB96dv23ecOQUqFMKw!1~x(KXy1vWGI2n2p`1(b)w zQwZl!!#TG9I95OI3cN!BY6u}-ij))xQ^UD-i3k|eog!s2NDbq4fpqxe4iGrso-G0q zSD-J0)Nn?Mz=c^5xWL{h0tr`OK7-V7k1l}DxGxU^YwhPnz?k6_>1qb4VNZ&{&L$98 zXa6Arxvs!V3{peAQmNcv)xKi!bKwW3(I|*JwT8#+bOq5Sxtd%w~rAN zc2UyHS0G*vs^nE<;BW|Ru`dvTh$~RaVB9c_o3Wz{Jl_lgciG#S!rtl%tVb|dkG0um zza=Q)BIXrbTnu!#{ga@=IZly9>JR$5d+qFL%rN32k$R7Vv-|9Jg0{MdQgTh)AMsMS zMn>>-cFn`~k&-mwChd%1@O~ES5xZPaXzoCRi+mtIIQ&TLJ!+pPDC{DU@^=Dy%)U`j z)I~p=$Z$WqCT>42DCQ!OdbkJB6ZX4;5-y^Yl=uh4ONq0M;4GH-8QVXd^)^lzsEYLw zQUp5=0(#aC2@1K0AIuMqqSOw%ub@H~iBug*J#SAEG|ojLbp*}g1^Yxn5f_QnJYEj$ zveyWTx`H#3wGcL;&b~2K@k`6 zq!b)VsW0r$1;t%NPaG^I`qDOMvdVj1Bo1yp(N}g;LAeVYT~e??kOnbA|4Le z{IR^Wmbf}Fa?UWZ+v;NM!lgu~iCGzDp4mF5Aj{5al9OlVr}Il|R(-?H>66trYh;08 z*sYALti!+!{KSXa4M15P>>@XAm@2)E!A+pRv~#kuC~G2^k)6z_7gFO}zLKwhWC4R& zt{PO^G)ERtBD)3h=?a+B#T?K`m7;AU7A)NGvO$fQqz>lz0;+UYL&M1Jp47o$9)cd4 z?@*{DEvQU9piw_`Yh7;yQ~c8&Zr2ZJRAYNonuKc|FbRAC%N2!vD0{$fFuT1tvOw#_ zbiJPfS+K+WbeN2537M`XWL0(%3lwyMPLF0+Qq`k5-Uz9|^EOP{_=|mO{+W}Fza|a@ z1FPA!V#(sJbIWJUub5e8NMQcl>0M{fn9+4buaeS|?w#k)Ew5P7d3Je4*B*L0M<_Mj z^tnry7+tz_?b1d4#SZ^Z96NUOk%lp&eB9!NGfHQdm6r}0UR*kD*^1&W@B)UhWa&)& z7*CfuEEe`>md(PxWf)6OT2!_KyQl+`EL15_N_V$>@#rDr2G1;;v2bSD;!?;lwGV=G z7nGGQD4WKhpBgf(v(v-eF&YQfe-`-JuzXh9di=H5rv>h|Iu`^g5HQoON&7tTeBgPj zu-+C4uTOiv>ejAfbuktg3A$ z9U%XlYT71JnSWcA|Bht-YHp0GdPt>RJ!$Z;n5d3umg!sA)#xh6#Zd>a+v@CU zYGwW%nf<+HeK{)J{QnC_wRYTj^5=1vJgVLN|GUSvCx0pbA66r+{8jUx_}^@wbM3}j z{{P+M+EaeVFa7TL4Y!4=_Q1IRdJP;6zxtHtb2a=A)`5Ls2dz%Jg7N=zMv4=UuWKstuOHNv%hBxk5r^W%wf@yQh)riC$d8h%28k}H2QtfyHqZ1WhI=_O0 z7=*p!5BO}3KQ0&;=8j=!m}h)u-EB#)UL^kIO!>PCf6cVR)8-$IOAyoSI%na6vaU-` z>gtScx;i?RE?hW&Nmq=a$`(&sx^S^LUIU6t%PSTPDj!)ssC@Y1g%yjI$PjBnQ4gbZ z;ryAU3unz*QnpmmEm=Bk@zQ}aXD)VAj-J05iHk}n6m@em8ai`!*^+T(NaAGE%~&vP z#pux!dK49xmMxmw%P1W=wsgs~Wo4yh}U2K%jnm=v!5;wc5wQ-V9ub5RjecF;T z>GZs~p&RSe{V(IV^Cs*Hc$;M&(&z-qquncgA7Zn~b zc@LukjnfMav#`8uNwP(&??bIys`M`ys#5)^nz^O4mg;G=Ia{D~(X^S}j9K#+PCH-^ zDJAn4md_5!ANDJT`D4YPMygISO6M<}F;B0wxBqG+MM50Q^+>2%m(HkITsmXn{E7wT zdJekf(uS0IRCYmk5vUB~Fj%xu8AN3ytau5GKx}8&$k9WqSE4!@Eml#!WbW+pvYDY7 zbEYlU)4D~M9!*-3)1y_axw1zqOHyJ~HgHl6Tbh>Atr(_KDo2%DT4ka_i%Ljg{fo<{ z&8%`XiglM(lvgY%n^|nkDxbEXtTHK&6WwlABceC70|w>o)my}P!0>Rd-cprWIbO;! zN?ztwx~hSbrW70ST4hUkh|>Ow)TY?+F3FY?*j+(%U3u9GWuqutYHOlvoDx+nH_Spg zBdtxVORW45NyfGZN1~IqXC|!W7P}NY=X3VQtq@0U# zMa6Cry~VFCF6mN|T`HaEl-Voor0gNN)KF?PKh86fpcq562?qDAOmrdBRp z{JXNDS##%?l`nJ)Oh4qB{DF&+Jh!0zhL1TaG`OfJ)T2xHE`_1u!lIJGlEU7h&I>pZ zfX&j1^0NM7EpulucJYik{V@~Kxukoj^XyRPS*YWTd7T$6UbwVu2F`q)VMXvtZkehy zjjB;~T@6C_ha-kg3*F}=s^VOgSCLag(nVJ_?xL#3&8#Yq>Z0C~cV$G+D&gL`^G;qx zd3uvGCWCO?$qBkw@6y3zhQsC0T|DE+Idf+%mFQ!NdX^k0zIzSnd(;qLQbT;t8sdA^ z5Rck<%2`}`49>79KF*F+;^E*@E8W-@x6`d<>MAE86+oN)kbm{tG1|_bw7Yy zj{~rh12DY}P}id3LRF3`b#>zPKB-Kv_eo{E-Y1pux?Z$darbKUR>tdkE8}&&mGQdX z%J>vpaP-zx9^Dp@Pf;&6Pf9jLy~P$%OjE$pnjFAu-l5nLtzvOKR3WRx7Wa}4&>IwX z<;3d^f%tC9p7nV4qnMlCo|VbbN_8bTEfqN(nBuzRl%V@x|;< z2j~*0eTj5*s({mTsQ?30936TqQh`M4t(c6~TQM1}w_-9{x4L9>s*Q?Dy+%mgU5V!jFhR@m_8+cCw(>X)z}wHUnudZO{3yd+eXEwHjaurs7AIPrQ{RHoOPu`)iT9jkQ`mFe~JpqFa$9o3CV zkd2B?DW!@|DWn=b>IQ>MRCG!vD!PVD^ok}kNv)46N)_Wp`d&3SLuV9(fxq{3%a*Cm zry!%Aw2LbFBe@z8>vc^=>vc^=>vcu6@^2}bsOXeTRCEoQ=na<4JLL#dnWVI%icV>i zZZ))`6Q7d4+A%c>Q|*|#GCrkFPWqHeIq@mAa^h2}<;16yvzmhvrIFZ_W|!EM5=v}J z`6M=_bP}6VHi^|s26K~G-6Gsry<~2zUNSdUFPR&gQU>MXQ?0wEqe`84Q;Mge_41)T zt2=w6C~8cXl1UB2-5N%KDmtZ_DmtZ}sw8@2)BI{0GPyvPK-tv*Ftx!j+f?09N=2tM zjEdHK4#iQ?dYzKdDOROYr&Lu%rxqNy1yDjgb5=;jr(~o2r=FZ$TFu2oGP;ILQp&&u&}EWE)vYfXozhdPz9~J`yZVu{icZNyMc0r? zN)xNpDc!B2Q<_*sr_{3AaR;hd?YN^dKBX{D`jpZ*@hQb|;`Q>t%&O~fM60uC4cF3Y zey`fgY?(!>@d_Mss@{`3^eBI(*De`d&1IQqK$vnlmt@sX57cmtuRLu^37pxBnp*%9 zp;hXla?)EKb*b)RE*Y(xWHMSe$z-%%N?J!v!^Yy8`n8(lo7u}azJ?m5mQhmcWn^J` zRqtz^cs-lS^fl#^T3MBUs>!Q(z2PhK*G(SrMMc$~5>#|bDOGezAysrr8C7&j5mj_b z301USK=ej8xAUqq@tQ^k>XKRSLRMDJ3#qk|=#*M1vq{NBMWzOdM8o{MjNKHpqiI>Byn&zsE z*Q;6?uh*6F#WG0LTdXoZH6N9}rhN4JR_2ppn2uh(Au7}Nu5re}b*44VSSa4T7J0q= z=ztmq?dky6YlYO#KshyD4t%{*mB~}$okJnDcdIuCG>;2X%uS7d^=^b_6|MJTGCHLZ zRO*yksc60QD2p1N>ME1by2@m|t4v0xSdCIyLrL^DK_+T!klMOVyq+GdQe0Tg zu}~SWSE({yuTy2bUa89Xl;X?GU1~8^v|dWqO5J@-X?G`HFJ)zVy_A*ldMPX8Q`+9i zKc)0ed}=wJS=tm(t*e7#Cq5;;I$2dYE1@~nMT*`I$!NV9lF@oAB%}34NJgjBH92;u zIyiMkiuxU7)X5Rh>xBH>p`|VWP+ZeJo|rL)nA;lq}5#WC8JYX zS*6xn8O`A4p4twQdo`C7$-7Qfj*Fz~lo~ibS+@t;vvL}GQ7hw9%37^&uS}nMT-4x{ zoP1KM>|FbxUe%4JoS7C~irVF>00%*JLh9nHN=re=z5Y9ZOo}2UlTu3+ozmzk`T%EZ z_a@8#DeX?+>?*4Kfmasx#U_A2K)h@kgS4HHkc7>fJ;4A0B4PyI>!dpibh_K_4u+uc z6hsunh>RjCJ`ps4OJG1iWqd{l1eb}38f0W1;4&-&K@b!L{&nm8&V7B(sY>SmnfLjS z?*86W=T_Cdb>7m=y~(HR5U`b}>##lj3k;gC^e-s*SC{hr^o-)~GwAo$_FXf*aFyqg zKkbO+X;iX2i%K@jkCMn~^wH5jj%c~rDdNpuvCd52;Wkg=w-Jap-G}S%+)E%Mf>n22~4BDTW{(ROxFY*g{4B=VRPD~>)QOsy*Qd^D_qTvERC^vf`n zs2FSfvq}0`+4P=R9umJ-dU0lx$KD_nos7K1DOpZr$+9aYo32o9JCR|RW>)A`n2E;c z8EQa&r@TQX@*C*6SDs)cn;}uO8B*+NuGncfWlWO9(;Tsx7h+RViR}c0UCL1wD}Y{{ zs(C3k(Ca2M{^;r3ikCCca?|^8^i1c2n!ZPlw4X%uL=LGuLS~0_gv=g^%`S;eZhE?u zFR%PA`B_wz09spiZmAk6=QL)>B%Dj9DACX5sYxVOQd&BNI{@H0z*&B|PonbYH zCS;J4!m(zu=}c88lb@7G-&oBAMtbaH=?O*-gj2}QdBrC$wjYVNp|L;Z@M9#F9V}UP zrDQXyl*G&`vFv%7M9!;c`h-x8r{y+2`T;dwhYl|cMUEoYj3%fVOi(kHpk^pRWzYPf z2`U#atDI<7*)vwzGuExVX!Cyqug6V?Kuv0qD!e{ZUQ84kB;E?N-pc&uip(m5|QUY%gu2@yiDJUH^&L_ z<~YIa5{NQ?krm3@Y-3Q?g7_aw3VH-jLf)Z(uo`GPj%)&x!ZE z#3nbf$xUo><6~uce2TfE0xAdOJyC|~u*m~a3@EV>Yz{=?S8&9#-(_wy zSrlz1i`Yz7Sci#E>B{GJ|35Xx{>-@CzOD9&Px;FBiBI{;?Nhd~|Eb&9E=TPTdFm-P z`nMQ9KKi#9EtgBD3RHf6yHb6Zn}uSi7-RrJf;Eu?m;&2{lV|a zRR8^s!}~7N&!957k4^mUkJwBYu{i^X<%E^F%^5(^rhml#eV($W5>E*%mlS|>II1wkJ&6w~P2DUWg)9ly> zjnUt&`i}CiBTTYZCENO|A$0=zl&Sw0C-yEVOjYsWROCR|&#cO5c^FEL{4H?#sw(oo z5trK{{~K|+ZEL^OH^&i+YHMxe(JX2SEyTpDzTz1uykwU{ZnaCi8Z6tHlM4Hj{qR#5 zP9A$0BJZt=`A&Rb4!3D2-Y%=yr4@?&_60;yF+Kw#bmLn@BD2!O1L?xTt6m4=7o7}1YYX%;Dx=o!7 zC<`~j*mDwG!*&nglA+gybablNdA}QL;R+tXi5kH6Y2Gwu~mi;J$ zWv@MlVA+i_IFTdqT;rEKy}U?&azfkXT=>25i?e7EF4LMxp=M_I#AcwxW=O<3aU%`_^@I)LVOh^g{#LX;#^3R@rG* z*=g2z_w2NWPN-KVJ_kK#+wkyKTlU$X5J6?1S!JJDWuIBiM2Ea)Btgyj6zQ2CN2F)0 zvS+NaXRM|V^fJoM58U*QK5>>4=aUo5nJd|JkfKcwiDegk61@I4`;1=or4?`Xig>eI zxZJNll*!LSd4rrB-vYH%_O#`4dRi`f+H%>`mYdTH`!yqgn|{&KFM)|uTOdXkal;;?+!(he>U+Aj3p1yaHbbAB+6w!#61Z41AOFZ^EB~Z;w3p!?!5^Bm5=hBmA}3i*fx^ z`J3Q7&dx(-f26}>3VdJXr@+T4KNp_E`3(LTysG@G@S5@;!0XB%fj5-D3~wsm(_cfr z7_Xa?hw-eTVYvzL8a#ua46noYg0F%%;K#zR<_|o<&Sya>bgFOG8~Hh<+_IR{FLh&Zq~K(a$PGg*R}F;UBk_~ zR$i`a<>k7Dn{}l&WH%XO{1T-VCWbq%MzJ6Epj(@5CMb*=p6ZLI73eUw43>wY-T53lRX z;CfwOqny|EdgZ*X?^4d|dJ|l)>n+N8UALV{{pWaI*W=-OU3Vzwb$yg_Uf0Je=XE^~ zuGjS$%6VO{P|oYR20zfzgP*VK%6VNkl=Hf7D(7|W&Z7C@{JgF+<-D$QxL(%{c!qxR zx^BXGUGTbgXVZT5y3XNk$ivUq3*mZQSK((Oo}aH9aJ{a#!1=u8b)8kHKYCp+gmeFS zU9W)abzOsJ=nt>!x^iCE4duM9U6uMn|F+h3uAJ9(P5EnnT^Fyf8gM?(_u7v9UghKA zKU1E=A5?xie6#W%_@l}%hW|nNweY8u-wNNN{66?g%6||4r}7u!BRgp(c^-E0-xTw+ zqw<5{yDOgt-%I&I_*mu3;hFLe!QZ0%YWUlg-vXbgd?S3S@`vHaE8ha2rF@4SXdX^b zejt3I^2zYil`nvwseCDXiSo7Z70N#i?^V7YKBT+>U#omGyr%p)_@&CX_qRAL&W9_M zzX^Vo^2zXPl%EK{PI)){2IU`u->m#!;2V^G1O6T5KZ1W>`6KX+%3py0MENfMiMyDG zUnoBW{*dxx;J;IT8oa6eT=<`qUkran`4`}B39a98jvlwdbLIEJYs!BQZzz9(^DoU^ z@!F zzw*)kX3fPsxMec`Sa_~{0=%Yt9=xHv!uglW{O56g<)7sI%5UKO%D>0?SIGPia(?Ac za(?B`KhYQS&``b)+^v-P+u^zL+3=e3vpB!<)tvtvng0sTul%c=U-@@Azw!q;|G6^% zQ=DJ<$lYijYRbpL8_FlbU60H^AD%0(a(?A&IKT3BoPU+fzn=3eZ*YF)n>oMoEu6ns z=HGF5)Cc7myrz6AyaB)6(c>hJ@1y+eU7WvP`dYYqzw~vSU-{QK|A36Yhw~3ge~9xB zNq?I2Dmc>PGEC89yGLUnG4x+|{I?0dFYpz;Ia_M(+{wt*a2j^G*C(i##8UHHhzf$_%V`v`Sr=%YNZz!J)udS2uXTkGN zOJ5ClS4saQyrKL?c`R8Pw_rvSTFN3>lWc+pTs`A_64dp+DXP=jO9*5VI{~g{`-nJLbPkyb;^Hz9W z`SEb~1sT5xUR8cByrKLf@a&5+&*$MaBA>lhVt9s*^M&K1Mr&i$Kg%oufX%K$vk8B zp?Rn)9}jn5m+>>;RppD}4dnyyY(3?fWEU=OTDr`Dfwon=<~J@T&43!yC#UfoI>6 zd7g*Yl<&A7%|lc9o8kGlWuBwpb>%0*-3A%o1+OZ<0Nzl36+F9D=D7)8Q{I3#mH!r= z-zM`s3$H8RZY<4%`&Su%0KBSv61<^&0X(~1=2;4_DPIe3D*rS*zeDD^30_zJL%92n zjDHwjRsKA@p?s(PX&$mWWu6RPQ$7XWRDLo%zf0y>4zDY}2=4Bd@t=cNm46%FP<|gg z`>xFMU+|jpm*Gw2Z#aPFA^#rb$s9cngIARw1FtDR1zuOa9Ntj=A$U{y)o}NH*`HhB znevVBT=`~rRr#~&yg=fm&0ne4sfmfBE1+OU|g4dN_4sR&G9^O=bH{AU| z_WzggO!<@WTzT=Qc*Xnfs`7o{HRbK_y7D>jhVrxFP37moT|@T&N_eLHYw%q8J@BgX zhu}5k&%o=-M`tt-4dn;Go60A_-4A8|7r-;+UGQA_2jNxaSHo+{zX7kq4|Vj|2yZIi z49_;^u6S_#vl)*2#@uVmM;}C9-`(%lxl#e&u@~jQLT1IJ~KR20Xi0=6^4|s=S}`EB_eh zSAHGmzfb1BgYzr@8Ru921m{=&3g`cc%)iGWIDeFngV&Y66W&yQIy}2y=I`bF$}i>o z%D=?Rnee*u#qg%`_jCTA$^0MZ z{K~(=`IX?e3SBv;aik{ z5#IKY?Ef9`4&}dqFI4_#c)xNtp2oXQ`F`*Q{2E7(4tVv~)F1Y_aQ7SOXT$5tSHtt) z%J?hbP31ShYnx^K_u<*Y(jS61ls^rx{!Ye^Je=miJtBQ9ysmsAJpWG_e*(Ozd);LLcfzYL$oNfg_oDPC;dQuw`4=9q!<)+Yeh1A% z_E*Zo@rT2!%BREY%HIQTDqqFe<$vY;%6IKR z9Z-Ge>A+R{1kXy`3laj{36c(cbWgQoL~7jIluBBbAIKIaQ;_h{=aa3D{<-cbHEc(qN& z-vf7hNPh@kSN=3SA0y*O9!2xeRK6d)wx^8mfM9h=7S%1?&7gJpa- zysG>HctiQ8;n^WF&)4BK<@dmw%6|pV50!bIg4dOgn1=drn2g^SURC}MctiOdc=i^V z=PY0k6XOb>MF}kMd{WP30qxqj|_CQ-02~FTAR} z9bQ*H3*J<|nDZYc^Y?Rp^jUR8b?ysrEl&aeE#oc~yv{~FG({M(#g`MsQ9`R_UZaWem3IluDVa+-&_^26Xw z<;TIZ<7NJL!>h_yaen0=<^0OO#QEPT^WVYwmH(XcD=$9YEdE}lsr*&WpUeDv`ya#K zw{!<)*N!QCv`{|~`4p(s`9n)n)0jQb>%n18_GAro63I&cXMR_ z{{qjH?>w94AyJ-aDL@u=Au3*9}jORp86Ezw+xj{{or+yPRM7gPdRaQ=DJ< z$ayqgccRQc7M?4g2(KwW0p3u)g!7*y^RMOn%CF-5%5UcU$~SWUlV$$jaen20;rz;X zo{#fi`N43vQ06}xo-02MUQ^z~`IUc^^PeK~U&r~C-^uxvZ{qyQpXB_f%KRfwpz-F) z_lMV%Pl7j;p9puS$^6SWzw(PXzw&E1zw%o-|00?H0r)uhuBc;A!KW(U`CT;LdCJGb ztMG-$a{_z=d@uMicoV*21Z}vK^PEooT#WeZ;SG2Lz7bw~55@amtA)p-91p(&{u<{$ zgW?Z?k6l3Hs>2t-kA}PVQvBZV)8QFBho1+p!rS0i!D}l1Hh4qD{{r5G`{foM&%!$v zQ-8+5cRrE&Uxjo0c=!etKL_4~k3*j2@EzYr`FDn20?*(ae zGbz6x4n0ny{=4E0f`4%QLGb)+8Gk&y4(Ip^yjhX)ALKk$a-N?r!q>rhKJS7z;Q0vZ z=4QBCLV5T+e-U1V*C^cWbux{s3D4jiaJQ85@OiQj-Uc6y_#Su$za4%B=Z7BwU(fMf zl>Z9&Pv8wWpZ|Y=yKai-`5Em8SiHYm2ni?J@TQ8t z1@6wF{T_h*-V4v*yTc!ccc}PR;R{v#ey7oRt15mHyr$w8!mosn!hX+z*Wo<>m%tlv ze%`qbo}EkM>Oh{m;8i%UqX*&Z;C%i(1Fyr!AkX%TXk2%}x!xWGZ^F4w9t-d2q5g25 z)8SP(pFjQZ2Au1|C*WIDo*Uq8t0+JB|KH#ld@uBWg#Q}5PVd7ZevDh+OL-9P{v3So z=ylp-d0z1G&h2Tg_dfdF#k|?;y6@(_h}YMR&w|_Q&mS4`?CbRP-sgKC;<={~FKxJrEWob`eZ}*^& z=<2I1@9A68*;DBn>KhoWbgo|GmiDdc@97@u?rNVhdD^6SP-WT5-j$Wkfq~BRE8V?A z1LwPC1D&h7D_yHstvcT~8TM1fM-GY5rM(LW`j%FfclTCi%$->2Ja5fJ-`$?oLzVJ2 zVl#W^4)m?=AM^nel3ON*ExoH(&FG!qJG_Oz<>ryRZRY>iHhpck%|&$TzJSGDnoW|4@m|V#kl*Dt>J<&|=#BC1gc7Y~3aqlg<f|zQa(QOpY*Yqg0$M$8%6|GSPHPUCZ%Z#_p2r2NTwW$w9@*FdbaW z@g!87Of(fI!*l`~rs8Cnij!d~PKFaVTcvZ-L?`Y5NGr!gM{mGboF$3LqT*!IP;oL$ z#mO*=ll8>pM(;Q8JBi|C^5Ax^#;G_Nrs8B6#mP8|ll8r|YKqc|ByaWanLWIPlnbN}m5ER2TYWHb~fqoFt%rQ&2czCS8XCOQ-rqoGn5 zrQ&2co`Z^$iKgOYIlfCOP9{3k6{A#~4AXkE98W^U$wbroF-*nDFcl}mRGbV`aWYIx z%`g=w!&ICM)5I9X3jE{cBOTaWWc;lhII|j8bv39N!-m zClehCi_uUij8bv39M3_;$wX6evK-$f6(WWb+PKIf{S&k>6;$)&}{TQa=WSEMR zVJc3BsW=&?rDm9llVK`OhH2#(Msc#9m@FzzCY*|sVJc3BQJkzNCKtuY#G^P_Ps|t< zClgM^$uNqOaTF)(i77^LGVv%*)~PrdM{zQa;$$4f$#^JE)1t-6XedrbLvb=1ijz?) zPL@M)vK-%GC@dy8R0^Y1oGiz4P;oNRRGciwcS*&`M2EU!l!}vKT5p!)NvJrPXj(sp zsW=&?;$)bLlVK`OhH0r8rs8Cnij!elIfhZ3tS2UmijxVa;$)bLlVKDm>xs!laWe5J zPSz7MM#ag5Q*knk;$$4f$$DanQJhRXij#FJPR3E3jH5UiM{zP9iqnLSXmzq2s)glH zpDc$0Wtl2e#6yXScw(=iz}WCmGAvV>ig+Ro6)GD~l`7(i{Zg&6@uALGrfOxKR$#;v zd8lC7cv@7}sbpEFnq{4emUXIH)@c!1r@CdG3YT?SR@PCvA{$aON5#uFpz39v%9nN2 zugHefT%&^77ARqn4XNp)B4!&<6|;^qW;dXYMK+{n9F@$rKq-rCpju`(pqSYWsAhHp z%9-6j^~{txDlLYovKXd%W|-=kVbnA0iJj6L!U-mx3Xx%|D~3_etS8c-o|$;mGwX@{ zqMn&}szZiR&x~VLT2JIbJu~rGW5!X>jH8|zM?Eu+dS)C8(m3jwanv*8SY5`sp4knl znL|A@4N%XFqn;V(dS*AI=9=r7X~Ff(Zb(fZ>X~VPdS;yKnc2Yg%x*}{IM*}Ng6o;x zfO=*&a6K~{xSp8}T+if&iT=+#?B8B_4V6Xy<(1d4@{NWXXEdyCqoME_4NKB!sD?(V zELo2H4XN)jRRmbx#OduRb`^7I$DlTb?lEzeFtNIi07FqsmV?2 z*mC@c(LyrOv{Ws}2T#S)L{lv@OeNHEd`_tFnP{p$mg60yp3b%O@ z(}=2L<70nFTAZO&C`>%+qjh@Lv7R{EC@VIeYMpV^C+mq50oBRGhvFpv#;Q24i;`tD zoE=8P(lr`Rb)%s;84V|l(NLU>QgN~z`5V&WsKtjD`_s}QIzB)uPIi~^A<~O96HTYB z<#-3_ooJ#my#oNPQ5C+mqRz^gPHPsPbNij(!!`IR`@C{8vH6({2;PSz7A z0*aG~4`-_U8!IkOM#BkdG!!SJ;bYdPLQI(ck#e3w+5Of(fI%kf=OaWc_#x>}A;6%{8FP3NTL_;6@tnrJFc zhN(Cirs8BdajwOCg5qSdpg37i9Ay+I8&Ac_dSVJtoNPQ5C*vqi)>G$K;%K8d**sL7 zjH5VNPn-xSP9{E_sq$~ExHuUNC#2C(oQ#H}Z8Q`oqv3=x8j6!qDo&O|ak3mA9u+4W z9UmYSCmS6fA{8eSO{cBpcn9g^vC;8eQgJfTRGciwcS*&`MAPYNIX+cXoJ=&Gla}Md zp_OT(sW=&?;$)bLljX#@7Vim)lgWbOWIb_|QJic%6({S7DL`?u@l>3Qqc~YlonMKg zjpAhUP;oMj;$%H>BA_^#_;9AmKV#tHWHg+RMniEj8jiNnP@Ig06UJyLPDZIXSq{a? za(sAHoNRP_fK;4pbbN?ZoJ=&GwwB`^q?5-+$9GA^$wX6evK-$f6(o`oR8es< z(R5B)jt_@crirHFWSEMRVJc3R6X#mICn!!P3yPEV#8F0Zvhh@$tS6=b#mUA~aWanL zWIc6$C5|?Vlg&fL$vBFW^~8yQ;$-5(nW}#8$JNPlI3+EI`eZpAam%4XSq`U-UUZd84vrzQwRB%M@3Onz4ErUsi{H z)tA~n5x*2mZJ!zn&ym~6KgliWUD!7`BV4IU?R(NT+D_g|+sWH#d(>9i9<`0OQ?}A} zO0q4@SG+B6OU)&}7);OA)NSl{YP8R^-*j8r@3d%J-j?b!<&L-IZK<~9lS+EPTRC$n zyAO!9E;nvt-|>#4W7D=V+y0MfwzBVZYg#jj*5$@%&%?E(XvLac58Jl&wvp9XwoR`b9z_TuuIa3O*4uoIeuPssbM!Q^P)_YHye&YO@K5E#Ou%bN8J?Y(*+4GQX-mFtyW$uELXG~vE zIeE^U(`GNKESf%J!R%rWJu8qdq7!EpS5;lqxumDt^{*ZpRMFjCokN{&nZNYvV7J;-T=#V8xs|0W&aEu#T-npw zT3mfK^dt1XQe5V+wK4ReQe>s;rn+VQ11o!nmg$J)tNMB=BFtRZU|(fLXK$D9Wo7=! zenZ#F-pcC1Za;CYF&7i(e_k>;h}^}l-O_$P8w1_%ugsmd)-CJn@7BFJ;k?SJxXkR# zp3cERe~sC}Sf`eKU|{8tnFT+Ce0+TaJtWBw6Coy+ml^4`_$ zOIEM!={jO%muoM6TG2VU!nJpu-|O?y*P#L0a$fhq;L5&U@k7OL8|d!oEE?du{+=P% z9%j1Tf7`yi&;K~oy~h7rTwT`(^@UTWy?X_&r@NxdC*hx{DP35XTJZPhEcIc2H=V0i zF77T!O$G3E=L7nGa9L;m(G}Ne-@*UK?H7&A z{ZGy<0%YN*)<1kbYL*H9o8j$;M&@DD5ZWIaero-r+t2cwUV8oYKHmQ|Bl8e^4S@T< zT~O!v`qTK)`P)pmUHpIC{;rX^|H-+#02v0ny|?09Ztt&f9v=QO(5|=^KDXaIDi6N7 zK>zp%eJTId^LMu2^7^p;FCLwT*u@wq?}z)(`{A$W`smk&wO@nwYtWvrudn+bcH;k8 z>;Ef4Ip2D;U!T~&9{(k1Kf`}59u2f_p#2tNSM(#1#ZTma~*3cpDFSTy(dstw(l=m5EyO0`g zYyN-j+rD8~`+YC$^gsD??SI++F&|s(iT9tOefGa>|0mzJIMm#J9NLdV`%N^A^8DuU z@Of~J+W+4!qW=HwB5KI-J}f-=Xa4$}*Wvvy@4HZ=_AAhizi>PL`Zv{{?@O=(?YW=2 zJ^%cg|E9>rV>dkR^8H8`a3D6SAH%UzLky8qE2JGuso^31%P3zw_`KuiwPJX& R{jb(e0-<-$}-Jjnl&iWQH`l{roU78O#fUe zEZ;lRkzsU>ysPr1uB*jr=A?=@=iXak)Wc7I_G!TzRW~F~zqb15ep5w;yjMONHdP>! zP)VEin?I<~V5cA0w^VKxzg5Y1cnZ9CI^oEGi<=IjuURf`xp!BPSy0vzgzFdbj)3&%Lb69shqHy-2pI1!}dlX#3nJ&{kxQ{edKrEpBI7Ju}e z|K*sx`M>1NIa-uIyzid4-PAVn_Uzo>1i$U+)Yvu(XN-WFXKpT2yQg8i6M~rP^cb2B;Kj($YmLx0Z9k7T4YXho&V z)HZJ1?X(~6(g8YXOe;GAS}vRnfp7fC*AS5Uhg#YZ7!;Y1(l~OsR--C*OYGyr?Jr%u z+QWHk!`t31BeiPREZY|d^{eojD_5@;{&G1opmwd$Xe>8>k0aWE$XnbizWp(W7FIwo z|6v1K$(!>&elw<(*|7|4;Zv8Pk-6|CZ=vJo@7!7eMz|f%?T#20Ijh^s#rAEq2f!|j z46a@I@jyywzZ1~u#!RfY=iyWc7l+B8^ZtR07`PO$^YE@pwr%`A%Au;5W+BaWs98+g zBW<$qVQgXkM>}e@k~ui@pR4D4QVTzXO+6T4lj*y2)TNTbRrA7kMjm#|wY{xhCRMv~~5f`T5A$23_>Hzn&}U=fCGl z`uY92$Zris=w*AHE9v8ib0vLjcP{cs!zL-zN8h=~yA7M@eOz_6q>rzijg-BnNlHWL zSK<9^y4#;vsnZ5j&?ay($T?ZN;=x& zOk{B*?&#HjAWoBP?LhUq?1$rhz!UXu6Odtsgh3qb*iM3 zU!RKnp2MA7b1G7^g{PD4PL*`B@2SYN7EMwf#ZFc}wdti6S3I3Ocp~yvtFC(B#V1NS z`Rs|3PCj%Z(xvrCz3i#Nl1^SJEa_yTF!EDt?&Rx*5q}%c1<{*jWNe{rOw=NpeiN_FL)hmJ(L zb@lYT;*pY`Uvnf9?b@XLpV;$%e}djEe%KG6T3Z9{BHwmhuFrObpCb2l>#p}<_u-O0 ze|xy3&sz>hQfyB;t9Q7hzikee^tbZi$V)c&_t>Gx54NYj_a7?h@8Uy|7P(EDWVD0+ zUVq4S@$4x)^yAg5OY;`?IzKV5RZ@d2xRl_r?)x7%J(4>@shW|)-K$pTB! z-}&DTXml)Z&Z*SAotLe`H-3oR)niEHi5WSOf_>@HKkKM+(fo=kYfjRjElGn^>)LJF zLvQfW?$EneuHxg<(_61x9S+|gfA7lG_3*vVPgkyfhW^NvtEb@mfW(!nt)tWKRP{`I zYjowEs+pPpZglURs$ut^pz7Oop-gUR|2(rtsbp(I-OQ9!qXwXf@ZUX$uUuV<&o0G& zp+XOXGB9-EPtl>1RrfRu=ZA1+G`FJagZ*t!Um~#?^`rh-%5K>co>}l!mA>N7DdXr} zbw0*tQG8W%z8O^pMQ6`aA(bCBL+YwIXk6q=RWVv6tX_-$8&oe3GxIDA&a96!YN_O3;0fC@eK?q;B;Re5ry5qO zZznv4oBv|5oUv3aH37xUDG3l+p)|tkjh5_)R6Bz?M^e z+n_BgDd|aU@;fYdU;%tJ_e1rhIRo+SNBDLwzJTS!&d-GcOgqgQ9Es#z^y zWXa_ePI5SX8Wt$8@KnuCzY$|sQ13z2Iq5$}?K!Gys1!EWNbQ3HE7B|AL1Q|Ir7wYE z$xY~BU3z0QP3d4mdJ8;grq)88chZmGL38RtJUxmLTBt9f>IX)~BKXlMd3owB0IMWF zjonXckENf%w?^6~=xAEb#Wb(j}_7-v^~tdM?zrmc^#~ zW6>{`s2cvuNUNQKYSyyCY5qT>mzJnDp}lad8qb7=tz}22`8Po&)#X8|8lLVS1F=+e z1syJ(?w^c@-(eYRS$ulAY%E+!?W5xjGs?|DJzAY`{LFF@JbqdwL11fH(e!f9<8eaO zc8+J1`$!pO4As!=NFa7^xrXMJ?T@MUs{JMCRmvp%88gkoA3*SxavdCI{s!g=cvET* zAfMs?8B5;rGL&X*yfz}m0D z$$2G2EZAHI1&5jEU{FuM8)@+t?C@(ZQ^|1iXtO7v#Z@@)H@+qoZyp^Dto=_IdE;eb z`=!MLa7dSVIrtR`wOGmUe~ za-u~T|1kDx+mpm%InioQLi{dRZu<^m`=y1Ia7ZKi2HsG7xc2VE-p5Z+$-RRg;BX1RZ*}N(?L_#{GyJHW zkL*w%`~-wo$!EKBd;!L1I-jbhaz2Rp)7SaLHJuM})A_oLzRl&7FA6syCzM--|fPQ>u6H}UltzX z?-IwuoAjIDjnBxy?3#4P3@Vw^G5T4Qvujep8e(};`vEx2!0ehdf!Im@VxqK=$heWWnECO!Nrsk2%o%&tj~ zd`RZMj?rpQadu5waGF?ZCmY5GlZ+q08IQudq(yKxU}#k|gV{A{Nj)-IouV_L9m=jr zPYfhxOX(~)%)soLwEPw_LCs)xOuI>?FuNx0?MW;yrE9}s24>f!&&H53y4l!0 z!$;;hc$c(qCKsxGP^W0749%!>jasP zHM0%J+U6peeVQr4IBhG?lfgG=VEl&Dg%;i5UAtza4r-P54F=Obk4!={A9e=QVLX}R zn(5OFOveYvoYG8s7ciZclli+_2>MXmg+*AY^9EAqwMwmW!F1V6=89(4wgS`jD48VN z-P(?NV7gr)ldhQ=rNP)$;E^INWcfAKs6VLOmZ+>sn&~zKO!om~YG`IInjSZksjHa- zBf<0xlgZM|t3ANZ!o$G+=-{B6fg(W(+Z!knpv0) z=C=A|;+pvy$2zGi8Kb8Y$Z0L5HkjK-ld;jj_zg$pb%S?zOd%E4Djmg)dFLWBam^gU zj5&F&6R4Lv&=^d9cg3ARnyG{HQ*h9U(<|hz^gLF&`-~GvtJE(S%#_lQ>EK%E?XL4a zX3TrC$k>|st{#}F-N}SCvjmuL+6`zzR$Nnde^Aq>QzfI1JJ3kXi!+vzu{E;_&CFNG zgf(*-Z`6A~AQRV2P524Lci&H?Vg6x6dG0{#Fk{|--U+0cpD|-TP!2p?3!2%BdGW!f zWa64BgLP*0CS&w<$C*PJGZZ9cYif8Ms1&}>38a}p4Zu9~gcC?J7gE5?e%%Sw&mE{M zX3RMsJ8?AQONa6M=KkUY($o)_F(3ZV38a~ivETD5!3_vA*WVrJ<}5Iei}y0L{f3L%9w;1bHOYp&;WO!r*VE3u5bcr=7V%Fi{5ksX{I4&%*CHM zaf(gT3`jt;Fk>z`?gSd>4%7=%(_=!e9d`n0<{^B>Txpb}%X*l*PRejFtE!Q)hdUew`Q{w z2vxDUI2g=x`<+17y3IeBF`qx_1iH>`rZofeLK57_a9LmPHtjKEzF3P){CdflGz(j? z(%SZ&YqS^td_Xq?-;iRQIGoj{sN#=Q7?DkLpPapT=}cJ%=BM%@Z9|8Or% zaH}|E3Ezg!RLPj=HWz^THjX3{*UZll-1laI6X+&)orYLv(*iQ~&2F=jGUi(^kTPy@ zt2;0wyuF=FTr)Rg#@u{>O!!uJowBK5w*2h`y3K7y=7V`B6K-_47ACn(P0E<>HY63- zR1s#(tu~qP?e0oPu;1@pN5;OxZDwJ{+&0w-bf?<{F=M{J#EIiJp^U1fKy6>=1e)xw zbhb8_9lM-Bce%}5I6v`2PM`v}IfNN==UFF^X1Zd=+~u!C*TUUWrzvERjOCaycQ+rcNdw2W|m?W`ScJOds=a8aK&a+!*uo8SyHhQ1?D5nn4kOME4vZguXoI0=Oz#HozPm^&h^pB5@rwVxLKU2a zxMucZemT&LOyE9u9Rp9%4|!z5ni-54^Wb>rb`7dh5N_^!tO3aV35Ahi9%9gO=aYPI%!tJKncyv!i@QQ4Knsa z?&cb$f;rWeOiVMA@%s5ApNuivU8fCY%s=sA4o0M@6ztvUxn$y+ISU>36|E){nB#74 zIcChi-XRm#%*>Hs{{D(g!fiqsbvl6h=M*V>uDiL}z z1~cZ_j%0$G8QC7px#48u#il9Vdat(yb$&9bz&v+z(`tgb@F;9c)%dP$}vsQpQ5JdJ<1ks=7cbsHrNLI@44In0H8ani^0W zRJsZ^Cl^@cZgFupa2cu}sj#NjHV2idZX%V?)X$h~N~tg@d$GI0%9uY(t5u|8ZWYSB zxeK^5YBM=wiMv{1Gf;l@C8?mM9?Jz)R^cyHU}Tyy@wzFeQsAVfS%Jsg4OXuYs=TU8 zDvSy;7W}M)lmB&TcvnGnA(zmqJ&Yr(s78~rm%3YgvJt3C>K;-tO(igqR#r<$8Oz+Y zI&=nAMZH`L;-^_b&GpAzT2*~O)#92e!dzNS9U&EX+}&a$yp5`>i=@JuYT6rA4OJ0N zIOIP~4aa9(Urm)m&W^ZSd<9chE!Ce?OjF%3q1IM6lQN!g*IJGlHJ~0M71UHNrqnv> zX;N`kA!qXE<%6rMwvY=v>27f#Uf%W8SERz4s)b#wul^vF&{QeRb`4Z&00(U^cQ^Pt z=GBI(9;r}Fb4y2pyGC^-XGGoAI$&naQrD6SYHB40Yow-TTt05LCSv0-Qr@n8+^^wB~r1cqWN1O!5*myu!U+0 z9f6#BXDz2%tvY^_l6QmNF+KoxJgG#DP16$=DSl{8GI;z^BLXZPA z_YeMb*GYAxYPP1H>SZ7!(ZY67X4rmEtl(?`uB71vZtOtN|EDN>1$=1yXg?W^7*XFTH` z+0!_(e(DQS0ZpyPB->w|BxP&r+z?O$ln-J;BGptrCfR`@6(ASZ+;~i~gH$I{F-@iV zK@Cp~x|>u&Q#~-r4pECp8LLYM7BVt#uK;eSdWl@X<&4aoRX`0>yGYrZ znt@4nxH?QKsHxX6$&OIxNrg3aEhgEKsyvi{Cvi|A176M@xEhn}DAkNyT&s2yCfU)d zFR6s4+F%#2RTD`W&z6kL$gE!t)O9LEDxj&4Fv(u8RyKh6kbpI}4wLK+>TRkP)YOm; zpl($ANrg4_CI%a$ekT>v)PIm2d}CE|LyQ&IRQ<7-WrL~?xrFBCwFfm$btYxR+#~x5 zlk9jkic~;TFV+M#K}{iL$D(_-L6ZF!uZ)}3^8|xZeg+(7Ucx)&7PXyJOjBJk$=<4d zAeGS6SxmCGsWYSkYq)RJU`@O$C#f>m&?Qd_CfP@BY%O?qyJ}1>rd7-64C)Tmi&R2W z0Zg)YsvxPrbM9b2V3M7z?stM|YAhz%yVP<}kYr<;>)I1sf!gQ<)6{xQvUjV`oM6wp zgZ+j{c8dDV38tyum}Ku!CR|n!OH=nzlAWq*l1pgry>3u#nrcrf@Pa$oSD0j{t6`*q znkq8@)C@J*38txDm}F9v67w&!EgUSz?5kBBTYu&-%f60M=h*3?*1vRw^lWa)!CKc1vZeYH! z!e0!)W1^-?Z5;w$2^wy56AXDXTGE`7Q-Xb~Yy2M^r6xF_$wk4`2p+RCOSg(9|1wpysRLqyjIy zgMHKh)B<%Esi3CrP6f44Eg%&GOijxYw;tnlgL&;|0UJJ@ZQWFJ?3NCh>u7lTFA zcv3M!V$FL6RNV58x_Qttk%4{~Aa66UtHW153nua1$*(NxEB zpk7l(Ga8tv5KaCgJ;A-Ms*@`aN9xUnpx#hzNiEgXyQ!cys3D{_XzHa42zgDedc~HAlJ5oiO>Xi*@w;D>y|7OX^jLfch5qzNT zB$cBn{AUc`hw9NBh!3}!<}$m3`$#=c)e1CKtsba7YCEZ=np)Kc)W_-vQX4dN3>*AJ zoguYfQ|-t4!R=LL;Gr?iD$?8-Je{Aa#-#k4+#_3b4XDplFH$+0stA{w?{gI-mA@(a z_8v&GKj1~PUo9gTmhv~jVP?CspuSY=Nd?~GD5UOz4*R}Rdq~AKwSE|=uhlQ4f^WNP z)y8Z08+DnKu^AOivX5H)sW!a(R#j<PNMeRB)@i)8_BMC5jTNBU5!H}XLQ~`L3Qee7QsMXAwF=?J z^8KuCAQjl|R+Gws`bEtk6&Dqv$^QbA?62x^a={($YQJKVJ*r+KWyIa;OH8uI)W@V^ zntBQEujA@hQua=FtpFz3-_#XSiIC=IVv;RX_{#?PXR2N9YL|wCI-y#V3hZ{PEtqdk zs==hHy#n4IyU+m*pV|Dj@}Vw!px@0UN-d!+1-+_kdt zt~{;2BbCt9SYW;)^%tq|o|0OSWS8NU|Ch>yECCne$0g3lJc~*8Z*>i+xTe0qLI0z= zlL~&~u2p#?s59zDQpR4lsx%PPziK9_7^si|FXs-#3(0p@MabEox~tt@9@IJYI;n)F zB6#JWSD%myf99^WbQGuy>L{te=WewOFX4;oY8!|TKf-J7Xg;`0s#;rA!F}#(t?GgL zPqiUseBoA~K@{I*l}{?Bsmj>JE9!Pq_I`J*pT=TJx~k@pOK2`u1C(K|Ar=18UF{?$ zS!He`75K`nnqiVP&F@LYzlt{f9FlBCC4k9hD%=$?q_4UBAt;ks7W|1xR;<+ks-a;y-sh%}3$yP9DJHa&fQ3t42(R{`U_Psk; zXZ#&?CG#C8n5KsKK~*-tc7kcDMJZ5K%s-u2qCzzJP4JGbYT{o7!hL?g9c&`bM>VrP zsi3A7UGR5}JAuFVLFiG$&T*2X`?1TQpxSbEy+dQ=JBbs%^gN z1k=GkP#^97`%7oT^b>w*{4BPVWTq;hbr1DSpznFqb*OesTw^fY(k-bG;Kx zQ|WlSw=(xQ!8A1#RcrGXQVC7<4mJnZ#=PtVJK_#DH4{`@vr1>|Vo*~DG3~T7Tak)s z>fNrO+M9z&C63t97rs(;LUr&QcQivp0|^c@3=T8#6V%tqTuCafshXH&JDYEl3jXY_ zbu|N27jr);;}^GDI2=@0^LJ7)QZUOt3f2X)Y&SEx3y#VD)m?25o=Drozf^}aqNy7P zfyy;IlL{Yo*Sd^z+ua;RDsarLUdJrk!<+&NvTR&)Z859#G#68~;Bj}gdoWlpa~&z; zH@E862UKr!H>sGWuGRq6$NY(uUFfcLJ!RQE^8&eq<_>p&YJJTLaMIwZ?u5JAFt{Xq z{mka10w>+-R?M>f&3>ffn##j0JHWh&RPcAM6{5-Sj#+k~8760(a<_Ot&c`5g6{(n} z)?k($Y;GoH|KYCHAOI@g{E}2cQ`@cqHN-qcDjfRLUF|8%d_&EYZaC<`X}6k!S$3FN zmsDI+lQ7tDvkR$Uk-Jt^IPi@yN0T!Ca;u*(*2s`~54o7;e#9(0%3MOq{@Yy*|DDe_ z+I*Q*LQ`?Pm98~EAQk?{U27y}+3UIWdpw!=$fvU!%M zVZb+d`S!y1%r0%<-Cbr`nEf;>sHs+%Wed!vq~e;IjaTU1W*<@k+jOgmINWLGCQ>m?RcH!oy19>(VYzF4*cj9d z^8_f!vO&$2#uPTwOzMGyj%zB0S@vGDHmN|8yTy^1W$!aPk_v08QcY0zn;q;2Ios!M@eF3!2hD|~Vw#$SU7TgEC1oVLYdwUuLgr3VK~0UtEE_ftk&257(V4y$ z=jtKz9Jv7g83??b^YS=m+1X~fo;V+2O}#S!)EqOLR6YCyuklWK z*qlHr7Sh}X%zX3AS>%i~ceVMLWgju0A{ErsLjh2ans1ScYpO3^r}Itxg$Ud!>Fx&q z#aIhM=1Fp4&Hatn@IuoE$pt>wHFaM-P>aj}DLcd6V&!a5i_K1?Vw$=Wv+NRcBq<}a zq!wh^8kl7tGw&uBbU7$D0@PA-5vjPQHltc*zCGE;pNzGRnAX-GM4<_9Ye6 zR9nolE6j<#Da*z+7q1WQDKkXX0)BUkJ@MLEX|5y{)>KDKrK`-hNhLHj8`ab1eo}T> zcZ1XMSLnWH%-_kyH1`5#+0|w;+}e=s%ekwi~#7;^m^t4#O`D z24a$Z&b*UgpgcE~3x}D*Fv&h|KI$~3sc*0YFPP7hifL*EUZ5|U+esxfwFQ&xTJr}| zfeIK4lPm?h4U_Ck<{2j#IZ@?@z`J#38F-?FQ>>{4nD<^b8iN2$UNL)-3RH9t z><}i|SIrN9qAcyuQumd?#2Hcd#!o$!;-UaDr*-946U!%pFcJO<7r>-Zc+8 zu|k>~hjX>n{MQLq)g3H`N%lR{4>>>03TkQv&c`;h38|Q-`q-e}H+z#xXezTjsO=$h z9JxR>cd)dU;C7e~IKecv43li!j5@(I)eJA4o#vZPFip*E2x^!4xf82;Ni0aRtuV>% zHVd6#E@xzp#!UKwY4xWoUsL-~eQ4GqmC)3LDxf|xJCF+0C<$g{zMlqak2#!F5R{W- z=}f6~a{e zqd5W<{GX7TYlOM>kXb<0Vw&25>F=<)kW^e#U*SdYlev~uLR0@V26e>TNy@0>9vJ@q zDdbC-hsXsqcNByDY@Q=!Yicg$+F#6aPy#Z6rm|~*`qj)P71q?1Y*0tdJW{b@6~f7% z4= z+CRFoCm|WQHGS^|QJ!76H71PwS@M!G&*DMb|f5FH!wF-0XS+g0bgr@posy%1+C1uoy zfnol0?!db+p`JGx6YFhitlP2G>V_M*9xR8UjjVy?YpzD+8usn0Rh{%7vb zhxqVFqqz!rFS@fiSIs)4j0W!BU&J$QSe;1)G*wg| z#_vP5{kyXW9n`%{n?!d=E!{}{=@IZSKn@YEO5wxXzRXEK264OJ5 z6(kkb)Qy-PGOhbb#WnRhezKIZmXk8B;SNxPzu>J`+S*9UCWRA9?rFT{%UGW|!L(|N z@I3mh-<)8YdJL0&S<8eJ4Nvx2?qJX5fGTIzBxP&rI~!Dat34=qpbcwoH$Yzn3xA0L zcZ#N7!P}vtHJOyr$Q`USKEPG7=998D)eu!>>jhF_P2JTKE@)pBYljm|bM@;$wW`)Z zCs<>5u+uF;RkQwef@#W+$-cVfhfgyYn5O>3OTLEHgj8Hqh$jDCJkvF;-sFrX?qHkS zgQ{hXBV}vqE&LF!Z9U)w)6|+&Pys9I1k=>?TA=D!Z#uC;P2Isp;#}3W@WVLGvNctN z$-bUd=mgW$i+DQgTNb1pIAxkDYznG@Rg097?T$4cyVx*fbs%SJu6Jp0*I2_zg*DY2 zK4N`Y7N$Q4rl|#Z#Wk`PIKi5^gAFSWsy$-bFYb|lTBruJg8Z*Dau6$XU~o$tWut>9gb)rTBxaDax@ zpEkT}VT~tcwiY_UT1FFpsJgv&!au(Fx?9@_7D{>iGmOkj@bu#AX?;)X zyry=hfa-1iO)9ljw9lWaZkeC4slHad(KyaPtLRLGtMIn(XALJ<&?@>eLWLL4AnRd* zu~yN82)AI#!PaJ{dYfp*X@GUGPs-( zHo6+&X)JlIbsxb%yXY4PtHV=>?|SQ1g28sni-6(UP`(?iL&W0kqAd`P!zP1Psp~LK zqFr=6z+Nw4$#GU!f`RsYTFSv;=8+6g6Rc}V*`j`iHZu=lt%=rDQsMT|Pq6)mu>D)D z7YWANM=xUg_3{ATW_?GnNE&$s4l{>h$8Wd(A{FSsq3=a?9^1de%Df)CTF@an?k{Nn zG@kGRs|&$chv?$~dsV~h`)+G8!H=bp?r@m7uRW-Htofu8qROJ`*$C8B>jhG&9itbp z{bOwa&a}QI80Z*n{5O1Rm%)#5aA{4;sWayf`Q!VHiWoNoo}JF zf?zB+`Uk@M$^u+$ed1Kljn+B?@UiLumsl4G?$3=5MtBECUuHEKLswXCG>otgMt|J8 zfncnAbR)v*_|w-D)?%k*_vkMO3o!bV)^>v79?|mu0vv@G&`Rqx!FZ2oPk_C;V4JI~ zz*r3A@5%Ff2Fhf1!j_-0I+3zP?MAf-+h1*sB(=0>^i^zsC5|p;JwhXV9*!p9D(wiP?~iq(x=T&uPRyZEYg9Vw%C^o_GHn9utHeBD||Fwi@i02spm9ozSY zwT)mwZ|?C@ILtiQ2-HUFdr~n`V^OukPP}RTO{z!~)!Km<{##b5aX6SjA8wFp#qb_| z+sYzUKq~ssIaMXp8@s#J8b%@}b+X|w^M0J0_pHgJ5~9v1P?^I(y>HDYW#r`=`0`P$ zy-ncVcIyRFwkWFg0nTXL+CeHvs-7j1qXmNRaGo%_)8jmH7SrL7}S zCbK9P)JIl;R6-OknVjjzS|3}TNEL~qTHj!;Pppxo{C(jF`%SgV)qr=OT6dEQkiyPU zwH*AN=4aL-a(3V7&*$Ov{e}-2Us>-H93*WmgTqXPzyA8hIzTEYDhobcGOMHd&iaQ` zSkwYkZBQMsN>9MiCPbY=H5k=Fs}ZR{KkRo1$RN!5x1l>^^(2>14gg)Ib5Q+cjU^Qn zMM?h0j-V3OeWYfJqWnChDyUzqCrQObQEL662dHD#22k*GLy@?3H$Xp5V_H9MeM;2= z{dsQFArWP!<5c}-9VZnQm4o+weN=^(nuvqmAc``^2vjGm8l?7%qJfPZV6=eWd|2(s zCB)%fP%4&e7|HcU!4#EVrQmJ-2)unXURvuT`bGU9X})5m{0bFJ<4u%-=)z=kMO|4|z1r+!=9^|kSg+lB9KWQ7;j2pSmwbD4 zV2XKt`h>~(Q|_8D_LiF_M;D}-^`b=|n(5KcQ_Q{5jj3k!=x?RXI?>Nk%@vuqO`O?- z%Jyl|Av!kAtQiewniZm-e*oogO*P9#Pkdx%ZrPM(S}J-?8Pi|3y>Z91sbfp3b=a~c z-5jR2G|4o#nb9ewtiYDL%9zInZy7q)9H}hW=O%i(zp6MP+|-8A=r0S_){{Lp-3I<; z$jBMsoH(7AFWx9e=M`XsoNnnx=gT}cPy|;`?hHUlemX=Z3I6wIRD__Mh^8Y_x z)wuQl<<*R^!=qcqnOoJM=#=s1*s5GqaZJcnhBC0L(UarN=1{8I1hZji3t_(@yNJ~1 z;$Jc^;+ca!(d&2SvTq1{sL(3~;wZy!RLQpKSa?0=vS*0!ZVnF_?L8H)=L)hvNHwQ@ zV;XbW9YpwJ%w=y7;V(0noj~Azpx1}YH&9&2A0mEcA-jMGzs!6acT{*)(;2bs0|GxQ z(hHZ_$C)_5<%JJqUg+i!-?)W^(afd>-~*9fbC?G_{8{F=;7Zp4}17Oz(d&6 zm`9YcoDsyC&*TneGq;=DL;}qFGnY+2Dlor|d6>(0X1+k$Z*JrGVIvC`udkO`5yS@x-ryHoCF*`-3b+|9B_h4A9LS+=MUA$POvMbo> zWiJZhayQG)6LJ&E-CRTi`+x3c*>yrH$ld%O&xCNfn`Pe#xohQamR%==%iWyS$(d2& z?z`D$;k}!K9xiut*u&*+j(ND;&2bMezMB&sA$POU+3D#_z9!^u4l@rhm%BN}T2Ig|{%H5n`{y%rKY$_omkh?jntJ5Lx z-E1?LnUK3V=;3lVhdq2#NbXt|PMDIrS$2^SE_but%^|{%ayzn*gj}Q-na|_$!u>uc zD}-bd2@wrh$QBa9J2RIJB!mxTF1tqvzm53|p1@(|ymLgT_`@{HLN<<&hF)VX+eQfA z&0O}35Pp!k>=+^ZFXpmegu_FIkqYlHLCSU!QUUkvKu()Q7$u+jZJEnX5mJ62bJ-_C z_yp$1Ju`71@(=`&O(LYiGOqBqrvmO2f*q3mA*B2c=CV74@b8!>+0IoW{14{1GX#vk zWMoMxP5{{#LMl{eF1tbqZ^>Ntgb?1Bd0kK7AoHvePVtQyEMzwbX=n*^*$YDWTIRA7 zgz)XmWgiIP-!kuA5*WvAoJxWCIHj@&gjBFn9WFaS2(Qju_J0uGin;9mAiO{GiJrg{ zm`@6M#QiK}-v?>vaptn?gYcJ`%bpLycQT*tY5xc2k1`KQg}+$HZV$rK;By&gNcMUV zj=u#%E;~I4@4#I4c@U19s$u!HdWS;BZ7kO7!gz?e?DLRCXAFLW$lS=ai3op2&g#_rM^Wzf0!!Jt!53c|Z3N%A` zdOJ;++rpjvXBa(L$W9H?)9abbJ`KXBNPxb2fcX-@!(-CEhlk#g03NYl0`$`Z6iNUO zH{f45aKvE`ufja;;msWmqn%@nt@NZKEw^XGxnPxHo5U2K&A9{!~S7^av1O#%$p`DNy^<$`py zLK!|~BW&mT7tw@8c%S6K^p49 zTsBY;K7zSypCJ5BY5z8N`*8jrmH?C7!Z4nZ03QCf1h`!J!*k8Wj=@Kgvfx9`^*TFyM?;jb~5tq-LA517lw z2h2mpk1S-{1F3*pozN+GP!F6|(cxha4=_)7csu5@-GQ_}h&be5+3Y~XO;_Kn*-tNnFqqQfv+HaHH_WN!^q+KD;5V?Bs>-VW-i+sNJHtBoSBf#4TRTa zZp^j~dHPLkLNfx*Cr68uZEG}3dX}aKhHeq;kY3R-NqiC#XK-iZ^vdHp2yGs5_mL=1Xt+I z9h%HsHZc%Bm$__VAbcfr<54HD@D0p^!fE~?$VV*VA~^72=7IToLuZ(WJv^g|GZP69 zufyD4ptloh$3pfhke&`=E*ljHzlpi*QXm{RNug7)P!E8cdeCjWNawgVJ@Akrn-fSw zxSldrkevyHf6rXDB@q56bJ>$XxUZ_yjRW zK9hOE!yjWVyAM!YJpXH1$le3eq4${^%k;qCFb{h8@66*KZo)r_&?$IaZ>Jh?dj1c4 zL`$xa@bJFO?TFq`ka^6*XE2xj1!Q24F^A0soank-_)!k||h=0;R1ID8=UpoibYJnrESGMDWGWMEI?<|TM;WbXhG zuQ8X61B8FbTy_l*ewcaeDZQirGKb&OQO^VP6}D!n;lvFEJfaQ@+r!&24|@1O=3x(? zz&z&R_c4z)=*5Xs}j6Q;<%mW_YgSqYD*D(*4@Q{J8yIF)w1o20i$2|O5=5Y_-!aU*O zUobaT+thA=z8c2yS|Mj-0gt%M6>JZ$P}?aV^zf$4!yev~dCbFaU>*;7#8egu4`0OG zcvc_5^UMPtzLmM{;kXA2-c3Q~A(@JkEW(}&CKSL5F%PfCJnrEwnI}BFA9EvS8~6&) zSGfMh!#fNR(1mdybKAooXC7o;-)YEL$2{iY+nFak{2Su%{4Y!MOG78QLU4_3;7hns zhiAgWD>Ih``K5d_=7HyIY^J!KUd)5f+0OH~RJdLOpn#X~yCuMLHsWIbs04Uk=g%?^ zdiZAMF&7VEgP*fVxCHW}%w^Sm>Ch$SvgE$-vUPceUa+xxaYwV5Cp^4cT{!=A?qAd^ zjN}SI55H3ac=%ii;Nh#72iEHCzbWmn4e8<&3E-)akN_Tzo4C*bUeensUC-gNn!e0X z1Lm@nKK^fk^y{*jypz;iH%*Jp3*R@Twl*5#~V;e^%Nj4)YJk^xDEA;i>Qi z^T2vNz;Dch9)6X1%)=`;aAqRm=6L>_v+%#>1b|bg?aw#wsZZ(`UrL~&++i@ndf`>Y32nUo^p*d6H7h3c8J9Wk7&ny zzlRTIUgY7oF!yiJ2O#a|czBe{hw?q*4Hg9+zK8iz4?n_ugNL7EzTdp6}szGcWM)1V*FZ@g9vcSCXLguo%yl|t5)4nV%FT4tK zBlMm=f*cmIs=QRlV=gPo3lB1v<>ZCWWG-vT3xABcEF>Qi@e&JJMqc<1=D{6$N55xo z#C3j}dCbF8n(`^wsg(~IwOJ%|VYFi&-lbJA1~U)r*7+^W;~pMjE=$GBz@o(Q-(Nq} z8+wB)#5{ZtbNeH`e1dtx!!IzGwc#aj*=%PfXkB=`{zWumA*;d*&t)!4!VABSxvU2- z{2u1G7(Bj&FJf+gTEgl6dyz%LC9vXl=CTI7H1r*FSpZ)6pUh?Pci}0`_%7I25*XVL z;NRcUef)(kI&cM9^j#Vn%3M}_7k)c)S?yi;T;{UWyYOe22fpIxe-WEm#J|!z^aXQS z=p7#M=yi;_tnx1W5_4JNU3l5%eD1$-+An_ozlKFn1PAECTvm3MhK4auc*@@<0lwt` z+zu|kgfkuV^5qi1BVLmL9{zy@_)ZV-qXh8qzomT-Ps^bWg^Ywp1RP-mzSjfbb}%#o z4hqq>)@bCf51Bdl?CQAFo+=*{IAOVVnL9ZtyfQPS_ z06*ygK9B$&en{H)@G~I^;1QXvoS6t5(F4?HF6*kxDeKH!7F8EMoH?whP6HBt2lJ3D zsvaY47_(W(it55wFqh@jg}=_+_{BEx6{D|)@d5MLFE)`FeKm}O%G%I9Z3AC1`f3=za|Kx;UAWnX?~dPXDk;1wb6FZ)cn)(} z7hQNC=C~+2UH>A+u#hFug->H1{?j(_6{D|)v52{>g)aPg=CTmF@U6^)MK-knoZ=f_ zvXC{BF ztDOs<&s>%|7rutMtaC2>UFLS^oNeGMMqdr%OBS-ix$qOrWqEVqsvQsDf=w+5ugY8& zHW%K4dGMlBJ|vHe=!eUwGDj5=qvo6>g}DGkoC*2V_uuNEM6|W4RLt>m!-=^^ydlzl}k+sAICiG z;WL;gJbW>8+tk~6o_P#8UjGu{T^5F=SJ=-y=;6OHk9+tP=CVAwv|q7T=?D0Wj%7?k206V$b~=K0peprvJ|<9&0Im2As7BR zb6JC2_)+Gv0J-o>%w_d);pIB=08)8bND+-#$hzagZRWD*xbRWTWyNvflbOqMQRHlT=+=lxS%+`gimHJi-`-L=WzJ^FRfQt%@t%FajCGGxhx_sd>?aJKwS87 z=CXRY@GH!nrNd$VMO5nS%!Di)F1#6YSv6dEZ|1UMxbQK|Ww~(S)0xX!;l%O$FJTcc zr_aP%=CWA0JiBd^hIq|y;a@SAWx|CQGM6>Ng^Oc90}mzt0X`zJ-{aBvPicK0DsFzAKy?O#$PhBUs=fV z+*08Zb6J~PIOZR^NNekXn=qGExutv$=DZ}g5s>HqYgrh)qBRJ5-NiiM;SV#nJ$x1O zpoec{9`^7(n15(0JmN4{hgfYm#ysHR>xjeizwHq_xI)mwzhfTu@IRQxJUpo<55U8# zGfyDL`%g|mOBP0beFS}(2RuB;-1hL9%!3}jlzG_2>Hc5GBIXi!0mqrgJ^TRkgohU~ zHyY>zNbTj!M8Lyg10Co2-}Z?1Tp{S;`OL!}ek=2shliQRJ$wc8L<4^Qms7BTg)Dz9 z{A1>UhWf}7%x&iIPr&p#$2{!erF-)=A)MwPsx)9B%U(-EotZmpUYGpOs>7IvuW>pg zR!9Jk*dPHs{9_5=;Ry-QNDpvc+V^l=ZyIiI`1^m4z%60vzV~pO zxzSh;Fq*mT;RVcPEo+$}++~N_r}8lWB4QE%Kfd54{2dA4;rk_khZjl!4>$6hz(!M7 z`*{AVu#jb|C2$V&u)6}3&tonNR!jLHb6Krg_)O-qQnm1&;Qa;fQ7+pNDJ@4-1hLH%yB(xd`bD+C4h(HMkzR8 zS%^BzdH#X_*HZ%UdeYL+W(nZoUq}ECFO&c+^bVJ@71P-@|cR9h`|!+#@!ykhP{WX<`jyKXX}VS~#w*jt!-@asmtY_jh=J zc|Nz3!@R)ZC4c`jfJKZe+^U=!cSu8RoB;CU^rOtf%;Owj9do;_Qy%`+jb0x}dFG3V z!u@wt0n8%q{WZs#1g1OE72IjIDHC%r5nu#2r|79s^n+5K6 zL$_snr$bWVE#@)id0hS*=CT@fIp#&oWhrVY?;q&2U(kV{|D{4x7BLX`l8b8~b6Ji$ zodZl_E^ARsdEB{%u8EFLJ5qif^8oW4#rNMQEMz@u=s3NOGnd7vp#r^91~~y_C2A>O zpLwv06IjakV(zR#ZQz-u*Z4tj{;{VZM3(QK}e&s=6`HS;iYn>)0fdE9o|$>#tE znFn$m9%g=#c`U>tz@pM%r$ce(a_-wQ-_JaW%j25kIDiE6x0p|19_#J|&St(u$}m4@)O(%WfB%C}@5 zU=G#kHH^8eP+fs}0drcO8bAM~!ZH@JIJH!GT>|uR0!#TXBmi?Me@X%{Z_R;IhVr$- zyc%$fZ`5O9zD^U<)<-^dCD(i9%o*|X~tMTl%M|-EK0NZm@CL4 z)KcMB=CT5{l)uW{S$^6uqi!v%2|FiCKbjWzKax}i(OoBNnkLx2#75aXX>izG!$o~Mx@_tYGm(9(0bnX%{5pJM&k|hnv}1)2i{@-=cPFP zf4i>Ja&~mcE_2V88oSNxq%C9jm>EO2EUaoRRuO+*(w3^#t+AH*W`pQ`wX9~PWcGVD zg{qOCXOxcwmM2H|)v~IUli3QRg4fjA(Th-}tgQNdroS`3&XKaqD@F&^wyKqtg}-wK zII2SQ-r81%I`DRRor__t=XRXwXq jr4_ZE+sqzI1EM^6(2CBhXEjbgFw1d;BcmOwTebcV_a?Mm diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c index d32e549cd3..590541a9e8 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c @@ -5,6 +5,7 @@ #include "../../nrLDPC_bnProc.h" #define NB_Z 51 void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t,int); +void nrLDPC_cnProc_BG2_generator_AVX2(uint16_t,int); int main() { uint16_t Z[NB_Z]={2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384}; @@ -13,6 +14,7 @@ int main() for(int i=0; i +#include +#include "../../nrLDPCdecoder_defs.h" +#include "../../nrLDPC_types.h" +#include "../../nrLDPC_bnProc.h" + +void nrLDPC_cnProc_BG2_generator_AVX512(uint16_t Z,int R) +{ + const char *ratestr[3]={"13","23","89"}; + + if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();} + + + // system("mkdir -p ../ldpc_gen_files"); + + char fname[50]; + sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG2_Z%d_%s_AVX512.c",Z,ratestr[R]); + FILE *fd=fopen(fname,"w"); + if (fd == NULL) {printf("Cannot create \n");abort();} + + fprintf(fd,"#include \n"); + fprintf(fd,"#include \n"); + + + fprintf(fd, "__m512i _mm512_sign_epi16(__m512i a, __m512i b){ \n"); /* Emulate _mm512_sign_epi16() with instructions that exist in the AVX-512 instruction set */ + fprintf(fd, "b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); \n" ); + fprintf(fd, "b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); \n" ); + fprintf(fd, " a = _mm512_mullo_epi16(a, b);\n"); + fprintf(fd, "return a;\n"); + fprintf(fd, "}\n" ); + + + fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]); + + const uint8_t* lut_numCnInCnGroups; + const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG2; + + if (R==0) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R15; + else if (R==1) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R13; + else if (R==2) lut_numCnInCnGroups = lut_numCnInCnGroups_BG2_R23; + else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();} + + //__m512i* p_cnProcBuf; + //__m512i* p_cnProcBufRes; + + // Number of CNs in Groups + uint32_t M; + uint32_t j; + uint32_t k; + // Offset to each bit within a group in terms of 64 Byte + uint32_t bitOffsetInGroup; + + //__m512i zmm0, min, sgn; + //__m512i* p_cnProcBufResBit; + + // const __m512i* p_ones = (__m512i*) ones256_epi8; + // const __m512i* p_maxLLR = (__m512i*) maxLLR256_epi8; + + + + // ===================================================================== + // Process group with 3 BNs + fprintf(fd,"//Process group with 3 BNs\n"); + // LUT with offsets for bits that need to be processed + // 1. bit proc requires LLRs of 2. and 3. bit, 2.bits of 1. and 3. etc. + // Offsets are in units of bitOffsetInGroup (1*384/64)=6 + // Offsets are in units of bitOffsetInGroup + const uint8_t lut_idxCnProcG3[3][2] = {{36,72}, {0,72}, {0,36}}; + + + fprintf(fd," __m512i zmm0, min, sgn,ones,maxLLR;\n"); + fprintf(fd," ones = _mm512_set1_epi8((char)1);\n"); + fprintf(fd," maxLLR = _mm512_set1_epi8((char)127);\n"); + + if (lut_numCnInCnGroups[0] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[0]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[0]*NR_LDPC_ZMAX)>>5; + + + // Set pointers to start of group 3 + //p_cnProcBuf = (__m512i*) &cnProcBuf [lut_startAddrCnGroups[0]]; + //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[0]]; + + // Loop over every BN + + for (j=0; j<3; j++) + { + // Set of results pointer to correct BN address + //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); + + // Loop over CNs + // for (i=0; i>5)+lut_idxCnProcG3[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + // 32 CNs of second BN + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][1]); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[0]>>5)+(j*bitOffsetInGroup)); + + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][0]+1); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + // 32 CNs of second BN + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>5)+lut_idxCnProcG3[j][1]+1); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[0]>>5)+(j*bitOffsetInGroup)+1); + + fprintf(fd," }\n"); + } + } + + // ===================================================================== + // Process group with 4 BNs + fprintf(fd,"//Process group with 4 BNs\n"); + // Offset is 20*384/64 = 120 + const uint16_t lut_idxCnProcG4[4][3] = {{120,240,360}, {0,240,360}, {0,120,360}, {0,120,240}}; + + if (lut_numCnInCnGroups[1] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[1]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[1]*NR_LDPC_ZMAX)>>5; + + + // Set pointers to start of group 4 + //p_cnProcBuf = (__m512i*) &cnProcBuf [lut_startAddrCnGroups[1]]; + //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; + + // Loop over every BN + for (j=0; j<4; j++) + { + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>5)+lut_idxCnProcG4[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + + // Loop over BNs + for (k=1; k<3; k++) + { + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>5)+lut_idxCnProcG4[j][k]); + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + + } + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[1]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + // ===================================================================== + // Process group with 5 BNs + fprintf(fd,"//Process group with 5 BNs\n"); + // Offset is 18*384/64 = 216 + const uint16_t lut_idxCnProcG5[5][4] = {{54,108,162,216}, {0,108,162,216}, + {0,54,162,216}, {0,54,108,216}, {0,54,108,162}}; + + + if (lut_numCnInCnGroups[2] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[2]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[2]*NR_LDPC_ZMAX)>>5; + + // Loop over every BN + + for (j=0; j<5; j++) + { + // Set of results pointer to correct BN address + //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>5)+lut_idxCnProcG5[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + + // Loop over BNs + for (k=1; k<4; k++) + { + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>5)+lut_idxCnProcG5[j][k]); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + } + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[2]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + // ===================================================================== + // Process group with 6 BNs + fprintf(fd,"//Process group with 6 BNs\n"); + // Offset is 3*384/64 = 18 + const uint16_t lut_idxCnProcG6[6][5] = {{18,36,54,72,90}, {0,36,54,72,90}, + {0,18,54,72,90}, {0,18,36,72,90}, + {0,18,36,54,90}, {0,18,36,54,72}}; + + + if (lut_numCnInCnGroups[3] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[3]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[3]*NR_LDPC_ZMAX)>>5; + + + // Set pointers to start of group 4 + //p_cnProcBuf = (__m512i*) &cnProcBuf [lut_startAddrCnGroups[1]]; + //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; + + // Loop over every BN + + for (j=0; j<6; j++) + { + // Set of results pointer to correct BN address + //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>5)+lut_idxCnProcG6[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + + // Loop over BNs + for (k=1; k<5; k++) + { + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>5)+lut_idxCnProcG6[j][k]); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + } + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[3]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + // ===================================================================== + // Process group with 8 BNs + fprintf(fd,"//Process group with 8 BNs\n"); + + // Offset is 2*384/64 = 12 + const uint8_t lut_idxCnProcG8[8][7] = {{12,24,36,48,60,72,84}, {0,24,36,48,60,72,84}, + {0,12,36,48,60,72,84}, {0,12,24,48,60,72,84}, + {0,12,24,36,60,72,84}, {0,12,24,36,48,72,84}, + {0,12,24,36,48,60,84}, {0,12,24,36,48,60,72}}; + + + if (lut_numCnInCnGroups[5] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[5]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[5]*NR_LDPC_ZMAX)>>5; + + + // Set pointers to start of group 4 + //p_cnProcBuf = (__m512i*) &cnProcBuf [lut_startAddrCnGroups[1]]; + //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; + + // Loop over every BN + + for (j=0; j<8; j++) + { + // Set of results pointer to correct BN address + //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>5)+lut_idxCnProcG8[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + + // Loop over BNs + for (k=1; k<7; k++) + { + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>5)+lut_idxCnProcG8[j][k]); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + } + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[5]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + // ===================================================================== + // Process group with 10 BNs + fprintf(fd,"//Process group with 10 BNs\n"); + // Offset is 2*384/64 = 12 + const uint8_t lut_idxCnProcG10[10][9] = {{12,24,36,48,60,72,84,96,108}, {0,24,36,48,60,72,84,96,108}, + {0,12,36,48,60,72,84,96,108}, {0,12,24,48,60,72,84,96,108}, + {0,12,24,36,60,72,84,96,108}, {0,12,24,36,48,72,84,96,108}, + {0,12,24,36,48,60,84,96,108}, {0,12,24,36,48,60,72,96,108}, + {0,12,24,36,48,60,72,84,108}, {0,12,24,36,48,60,144,84,96}}; + + + + + + if (lut_numCnInCnGroups[7] > 0) + { + // Number of groups of 64 CNs for parallel processing + // Ceil for values not divisible by 64 + M = (lut_numCnInCnGroups[7]*Z + 63)>>5; + + // Set the offset to each bit within a group in terms of 64 Byte + bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[7]*NR_LDPC_ZMAX)>>5; + + + // Set pointers to start of group 10 + //p_cnProcBuf = (__m512i*) &cnProcBuf [lut_startAddrCnGroups[1]]; + //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; + + // Loop over every BN + + for (j=0; j<10; j++) + { + // Set of results pointer to correct BN address + //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); + + // Loop over CNs + + fprintf(fd," for (int i=0;i<%d;i++) {\n",M); + // Abs and sign of 64 CNs (first BN) + // zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i]; + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[7]>>5)+lut_idxCnProcG10[j][0]); + // sgn = _mm512_sign_epi16(ones, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(ones, zmm0);\n"); + // min = _mm512_abs_epi8(zmm0); + fprintf(fd," min = _mm512_abs_epi8(zmm0);\n"); + + + // Loop over BNs + for (k=1; k<9; k++) + { + fprintf(fd," zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[7]>>5)+lut_idxCnProcG10[j][k]); + + // min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + fprintf(fd," min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n"); + + // sgn = _mm512_sign_epi16(sgn, zmm0); + fprintf(fd," sgn = _mm512_sign_epi16(sgn, zmm0);\n"); + } + + // Store result + // min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127 + fprintf(fd," min = _mm512_min_epu8(min, maxLLR);\n"); + // *p_cnProcBufResBit = _mm512_sign_epi16(min, sgn); + // p_cnProcBufResBit++; + fprintf(fd," ((__m512i*)cnProcBufRes)[%d+i] = _mm512_sign_epi16(min, sgn);\n",(lut_startAddrCnGroups[7]>>5)+(j*bitOffsetInGroup)); + fprintf(fd," }\n"); + } + } + + + + fprintf(fd,"}\n"); + fclose(fd); +}//end of the function nrLDPC_cnProc_BG2 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512 index 1954723c1d5938c334ded0694b848600f53336c6..776516a4d72e8d73d51b9ed5a957c8915d912bea 100644 GIT binary patch literal 205888 zcmeFacf4LjwSc|flbrPAr1#znDTD+91d>1khu(WhXn|k|UBQBZaDW)VC>^an%$nJ= z-@D?#ed-E@EO&L;o|$)>yDd#oam})&qq?MfFH5sUSx>H$vk6%@?(0*WDW)y0@ZTsF zo%=mfYL;1ASAL7?B4Sb9(iF)3(Gi{HevYBO^_ASxVlez)ogX=KKg-6abYsP}|7DTh z|FTn3eD0rB#N*bYpTl`8-1H*c^demDKNrPixu3Vsw)s1&U)L*)u*gko1Jp%xffiNtv+q-xfh<1t$xP^Yc9eo!mV6sSwdWJ(aLj9S+frC zGtW79T`^{5w(o)a?X~yH`EwRDhvv_bu660JOVQ8oNx&6|mA|D zXK7h{dB1Bcix;Qd9a9 z9GdPg;C}UH?vvZ`cl&Mp?#YcCf7!Uj9;-dYuxtK1IzWcUDbVQw*4Id z{$+K;I6C8_?}boDHO{^SuW`d0{TesE{Pt0gT9o7&aMF_|y!jHDuT15i^o&$lJtx0^ z!t|pWFaLci;Hm%ZLII5%UvGSB`;x}O*2eGt??pqJOY5DN)-WzR>6xg1{T{o5e|GVJ zqX68#4#ZB{T0fPj!k<%3Pmbq-(YRqrc5(f0Zvd{jus;g$=5r^#@=jn3!^HKcH*V@W zWxB|3T=B+^TUKvdvAHhe`oS(z%#5exi@p zPxkftseWER)8O^q{$4*j(CY((y?$<}*DnnB`tV4vkB;{G*jTS$9`E&u$zHci_xkh> zUcWNW>(&KcpIzkj>x;d969R8r@$E*h&mHRZ`D49)f0frCp5^t0^Su7#60a|=_xkhA zUSGPy>n|Vh`l~HofBl@-?Js$K^>weWWd*LkAMf?`rC$HE%Ija&7q+dqRyO~3_f0FV zZM?PNk>x8kH$1ZC3F9_y+rIDcENd+xF=hJ{GHqCKZDGTEuAP6`lfkG>N4;@+<4%JU zPv~qv|L2=;e(jmWt;=6~iB7cfjg1dY|KB&?T)nYr2fQl&HEwGw`-rBh7+OJw}!y`9YY2$S( zwmdQ1f;Vmph^xt*Vh@bi?W>L0*mS75H$1MFUEJ{G!K7~g?LR2}hg=#rMf%349`oV+ zgev06lg!d6bSZUMbLs`A&a6zG-<-PH)IM#cK5OdlE9>2<88$na)aNQw$2F%eGWBzn zsVdLF`B+nLtV~tEMe1p$zMa&zs2L4?;wGT;fyrB&PQh#3+H@*jwzcWBxH~=W&cK^o#=!;6<-Be=XI0ixN}axv)cq?{cW#DV zW$F%*Dis5+oqe$Uc~;1TdA~}E${uGlptF+WlwFd-}v;V1l#cN zl`AAm!^2w&Pv?+Z${|+-Wa>NAz8B__RO>fMprk`nhfNzxJ(hM!VKza?!!mC^6H>kcin zO2WEIgsMn5xH7ehgn#?*wi%a`u+54$25`>1Dk^@cGPR0|@2O0!qTe+7>;)j&CdRxwrLBA0X4t3hw6!tTpfj0(TmCn7|7L z9wm^3`>{OFm-9SNX&tNRC_@YtG0URSN>QbD^ftdtSci4eI$~=ca$~=!i$~>Py z%DjL;%DgjyRK+3!Df4awQs%`3QszAgq|8eRq|AE}NL4H+kTUN>AZ2bOkTUO2AZ0#~ zK+1eDfmDT4`jq)_0x9#61XAXs38c)&5=fbkC(u~dzq%Cr*UlCF%h*&jQc^4W9nyZXJS<6j)zhb6lvnI`Mbg&v^!dc^ zD$1>T`aDc(#fYlD;i{2s^}DX8((kSWVr$b&JF}kD1ed;mzCH^eeo@ zTbo|SV;=Quyd$?Z{RWTe)OI`oUcm$4RXhNGiwD4KcmVtk4}jm}0q_SrDta9cfIs2^ z@FzR~{)`8}U+@6hJ*Qf(JlXJOJwP0O*DXKzBSU>VXG9Pdos6;Q`Pa4}d;+0QAKJpdTIp z4R}=49}j>5cmNE<17Hvy0E6)W7=j1DP&@#J;WZ*J&JGz))fapGE)_lA*tUB-Sv&0U zKWV?m@B3S7Z|?DfTj}v#8fVbs>F(nxDWTKmSo80%ro!6j?tP-FJhiI3{~p+~?tWWE zcQ4}AN_Wq(D?D3?VCw_U<0=uX>hf=^Os(qj2a#IQ<-0XpmDF~dU4B%QSM2h|Hq_MR zAAF^Pkgg2G{CB(^_!&|wx_tMBt41hAB}`l^42T_t_y7=?N02y#@)SIT@>D#8@-#ez z(m?}4c?KTRzZwr=J`-=%)~2)Y)^2TDgNJCJjR*MK@Bm+n2lzR7fUm;?{9HW1&%*=! zd_2G}zyth3Jdn5u5Acie0Dn6k;P1c#{1QCCFU14=op^x13lH#j;{pC2Jdn5y5AgTm zE#A6fedE>@mmj%x#TBczuGp}4>xwJ0tt*=PY+Z5H@U1JZp1gI%HRRbyp7)Vw6M3#B z&voRvo;>d-&t~#`VBXdhA0*EW?Kbe4IRYlIJe+e1bf8Q`RTRa}RkwMV?QS=QHH_5Axhgp8Lr2S@PUZSr3rsLGpZ# zJfA1e7s&Gvc^)RuBb&Fbc$7R}TvbvT-CI=|#vUd!ZuaLwqK{ha-~o;CjW6|YL&|P5~*#fj3QpGs*J!+l~Imh>ndYvB??t4V^L*l zmC6`NYK6+^(UHp7{&Fj{tx08E7LYk1t40Z%Nv%*BJzJ;@A0}mX;gieD+qV5bfA!{@ zn;SQ+a19{VWmp6F36aff0Q2f&4d8{pr!{~V@mj6{%)@$|orT>E%O=4t5nM{J8^H~a z3!K&f45T#x1Fiv(9LC{`sdW21E}NQ6i!}htWevbe8`Bzq1?Ou38_1ku4~*FDry8-b zDFcW#0KK#ZKG^&xLN5(wQh~)CtO*WR~SZmr~2t08E`)nOe36U}}%HQlB;T z)yjIy)&SO!`pwGJam`pQGWD~Ssby;brf#lGE#tMR7m(T(HKU#%-kUg;mVC;5dSpzV(t~u`;#;or=Lyg zK9#8@g|*7m>5*!Ci^{pU22hL%#jKc?tpU8w?V}8?S}Nwhkg~05J6BTkH2||0v47%L zDs5)VyMB=pWJ|MUL|E4VBuj3Mx7|-{DTiDZkU2q0je5gI9Z{KDriI@|>cVzvl?!dx z`i+;G8&b6fV7Wi5Of6HbraoDjT4K^mrhYt9TTbL$Z2>0OpnMJ5jis=XW=cT7uhe1R()6O7RKzWEVk_)%k!?o z9{WO?eO2_>a*6xe&k~_ze95AYtzW8?+4>ntz0|dG^3_rR-xFo!B&-s^_gAJ?3E=sp zZfkmtT2(`@+{y*oRHDU5$_%X_=Rm3)zg)Lg>X@IsnA)1-S0$%^s7$Sr)9;eHA@JMq zxL6=EC%jovUX|>AEXu2F0t2a}58KrO3o9|H65f3iCYDkZUJS0IV(yip6OCVVakI(a*nCCe;&$BAeb1H#U;OTju)p?$? z@;qnfdDaq0m9ES4oR{ahAkTAAp2sZ#%Uw+>c7rNoe_3qXox_cLq*g9zS3Si^6OiI0AyATaPAmLl!(>x9NPZL;W;41_+8`w%tk zZxcwFpCgbmKTjZK{yu?}`G*ANS`7I| z{<7G%`~FJw9r&a2{#7#e%T^ygxh}~yYnkktNPs$q*nC1 zlCeK;PF25~5akv7UCG#=R9CxCpGSUBLBy)3&(}z;7&?`V{W&J3e%JLJ`rR!+AfJc+ zlcA7;dN=`hCN>>OAT3WFO(1QJIF`W8CLK@U3kFUkkc9bU0tsprfdq9bfdq9rfdu8o zx&(C=fdq9nfmG>Q0tspzfdq9Pfdq8{fdq9Cfdut-0txC80;$q>5=c<*CXk>mBaooh z6G%{35J*s05=c;25lEF@Lm)xDk3fRDmOz5Ko4#-z)Fq{hMud zc^{9>B&j3O#~)w`vHd*Kdn^zkBUE&6zAw@d2f%5gir z{L<$udQVj^-&C1e)yvNzwW62Pw@z$#jJbQ1SM24*7S!}~{qA=w@T}_P|3zv=FK4A; zcw1x4@%Hiuf!Nx#9uxO19$*@5D$PG@Bp|G4}hES0Js?sfLrjW z=vF)cZo>oMc02$+ga^Qf@c{S;9snQ31K?wLRCEU(03XK#;7&XM?!p7$6Lqf9j=t z(QNj5AL^>0qJ7?eUHMR-7KOFZ;diY}t?KZjNG_7ij1)ilPy~TFm z*GaAD@}(uc9Fx+6{U9Np0D@I+^dUl7z(XkO@DR!_cnD=zJPalEcu0RYJcPMB-YQnP z@sR1Bc)<0-1Fkn7aPCtFt}h;N{qTTmzyq#79&iKjsCFP8aD(uG8;l3s5Io?9;sG}d z54hoYz>UBIZX_Pnj=}?OG#+qc@PHeO2i!P3;Kt(tHvtd0iFm+G!lT;Bc)(4;18yoF zaMSRBn~n$E3_Rf6mk-=5Jm7Y~quSYcz|Fw}ZY~~h^YDP%5f8Zec);z12iyWY;1=Rh z?ap|>?Sco~B0S)B#RG0PJm7Z618y-MaC_hZwC&g4?H|X^ijN>w>Etd4`F@`5AZMH0sdt?z#qp0 z{0Th3pTq-v3m)K4;Q{_M9^lX5fy7tv0RJi;;9Kzk--ZYHvv`1i4G-|I;{pB+Jixz+ z2l%(}K;qkYfPV)M@aOOV|1KWj&*K69Jv_j_j|cb<@BsfI9^gO11Bn;#0RJ%_;6K3w z{HJ(;zlaC;&+q{MIUeBui3j*gc!2)`45AZrXz`Ni9-W89W^>~1H z!vnl~ME1Y~yeHngk}j*-&QKgKm9{gy)m5_&hD$59mUqI^c82odQgJ)Oq0W!m9WK4` z)%H|duc#{TwNNieDYyejtx#~K z?F@O7s)kD=qP*g8sn~{^W=QvcrGk)E3hpUVD->L5J4231Nx@yEf_uN^UDwnfk$Y?l z5nnvYC&$KZjT?XX=f=AmH~y({;~SfLZS2u_-O{d&*B#!qB$hpjkJ#NR9D^sgP^Dt7&M6+^z zsEAvOse2K_0`|i+cbE3<%-tV)E&k3p@9uo4Xu3iI>jq)v~jz^U!N*#_qOeC=eEU0oAZhM+B2nBwbT3F z%Z^!g^s@bdO`v-OYIZ{y$g+xUY6XYeL9@5n#(uP)oavxQok zes|IM9eJ0C!DnG#APQfJ9*j4XEv8A z{qr;Q7|ScYVoys-&T|a@UFUpn{X~AB=J!WRn@TU)lizXt&f-_?oE0$$T>rz!zrJT7 z>(aHpTlXG4dkre)Ez}R}QD0YAuv6+RrAyVl@p-yo-PqCHd-v?xqfd|SeR}oj-K%@A zUVXdw=-sEjTk(*CKE1ov*Hc-2mu@(&_1&nsTbC|HGSqkN(weKQs}sW>y}AwV2^v|C z?p`4t*W`u{>s4RhuY2EaJ$m-<*(b~T^{?yNwOh9yRMNMe(*(NJ*LCUAHT}`7fblw$ zrWNYCb}5inMX7>~?pdhs(%p3fvU#m`g)T!{Pbg-biqH8tg*r+jW0X+_F_1PC>La2# zy{wWhUFy34+rC>u@(Or)AitCOUBmBQ;vVDoH^S2j+4^%SWCOqZIx4LFs#;53&qCLF z=jPM+?MnC@eh(4e8oAd~<$Cv4t>JfW#Fbr_tY4b#1^x%DKO{RWJ7)a}>rcr}TYq|4 zj&_68-mrdXHfsHp^*d(l{-U;S>!&1KayW3x8u=YY>IwYLwdS()#;n}>De;n7oDgR*nESu0u{zHi$ zp4qvUW^{#YOv=AQHihth*=(-6C45$=)R|f2w{tAbzL)Z=(RRoj2}b_Ur2K!&eoKtn z)G}8SzBW?@ypny3>qk<|fdykKUC^XiF#;YG)sIkR{^~o=2rALkP{c^r+MMSLSr?r$ zxh^RbaUGXXPwuY8I=dxq*Fn*G{%XTNuc2EWDEd6&s$yEdRpz==e?3=arCVxA4>0N0 z+@jVYBepxadI8&qtC;uV*OQX^q;PwXd0Ib8=)+%k;FQpw{CVO~??jC}S6jXuEAiS; zoc9!=wxCM!w!FYkD0__e#^n95l(Vf+kJRo$YPDy>^`IQ7DJ?s8eQ0NIO0X4u!9pr@ zOZ137+ffN>21Xez>Z;2IbOf5xyHNW;YVXgrKQIHpqbs_h3!#P@N*GLT`9GqW|AWvz z!GAYtcjOxA?ec#VP{X0XV6L6xfAkhLq5PBbQd1r>Z0peFk}v;z0TcWeGW2jq1@wY$ z%DViQUcvtcs8=ihMa0&iThGOFh&j#~xi6#tXI&`zM-KlRT!@dPzF)N$TfTkz)j|Hy@9YTlX zt2Ly1A0YcC{`ca(XD9fttjqttJU=bVXJcJW@-P3#XCoOFjY;`OaAM?eXg{S!{!gdp z*#G+jKMLAS0`G2=HytXDsiFNoaWf!?rzd#{pmzT6lK6i(=WZ^}_Q;ON_J$uvWpk0m z-Al!_89FsP9J=kE9YpZhu&m{hToc`Zg{!cIC|8DT3XT=n* zEj;Rw+(U}|KRoe&Ve0?2^Z$K`|7XCh21dK`e{*&rC0)i}$L_hr{|k8k=DO^e#Q#gP z&t~uI6#rj<|DU4&ZRSsx^FQv|$Kix*Nnu`LeBtnHpTcX|?^6HoQwaV$BJaqJ$o8S- z_P?{T6N~+Cuk4+jqW}Hb`N&%xGHCz1DLVuDT~cHJdp?_47@z$Tn4JE<%H|a=%)VM9 z{YPMA_y~301pY5(8wuZ%Jq`Xh5x%FR#*_YZ*0&J&KV5UV1)j37F1YEz2^UJ38NR9P4bxd1XCeG1566c1CB-<})=QOtGDT zktun|k&q?E$Xfb{ueDivP|2FCTMVq_tvE;9<&ZJ+30}4~h7XSPXmxxSGGUI$B|aq@ z$iME46uNMXlWlnP!Z+x~37H_6A$zSc- z_AFbgRm>ivBts(2}KcqnGta zX~vePi@mZDzjTw@X2=%j`rmeh3;iFK_K>1tLQS4_Gp#-Sz+wP27y=FY^HUf0=U&|; zo%@onKurHcL2X8TfE!F5+Bu#7hyFKLcTz(C4+5??ce(x_NU7?vLDZ*(uP^sn&qDwA z1*)@dAZ2w0YxQEtX|Dg(q`Cedh&3YD|HBA(WtKgN7ODS-fp6&l{$OJ%Jt$8d+(7z} z)G~eHhmzXBUpHFbhhIOeA6goR5;L6p&eMMcbQ=X7>L|li3u)6k)nA}&aqUg{-BXOY z1~E^tZY?G*yOs3+C~^)WZ8S5F5ee6!_DNL>IiCSNc^<#s{aR5&v0_N z|E06e9%;L!p}o;QsFpOWc2RmvkEf7YJNl&ZVyaRd<1tGzr0iQplpMM@db_n)s`kpz zzt&)R)@?bRbz-dy>#NOt&ME<+>(nxi1;in=WP!V$#QBs~Z-w?Xw<+p&HLQBc=XV|H z`eLkZ6VDiXIBJP?G4q73kQbeG1AtavI{FZExhYMQqB`WW2S3Yg;Aj8J^}qdo5PxB@ zwa4~F((RuEXp2-(-zX)~Kl_u{K5jeI71|r^zyGfOA3+HPLXE*VHqP)jM(+Ng(sm;G7F_5{NrNVoXa5mNRua;Y7L5~uzjkuX>P_a~25|3Rtl zI(m~3Z^exOsC=zp0A-f+|3GRkIbU&hoiYPApA94P-2g5GlJQ9q@ zP{%<2GVXQie`(WMSFZo3LD^Z*AoTxu{7KjpCs9K;uDSl70KcY_Ya*0X|4*Ri;pDAP zT%68TX&MVg!@+S9=~E~{%jO8+l+;PYPlo!|7y4iB_8`9V`hN#(PNDy&Q=H+&*Z$(ElR|^(WO*a{WJp^dZ>x>seix%Wo9x%%idG&!CpU z+z%%APPA(l@#AUjoFs*v<3Q;DS->yAb}an|QT|R)sgUiGEdKtGv@1Dx1gG7Qk6nH1N-MH_cN^(Xsgp|+`Z&m-h+T`}7qbx)*>T>tM(Yt;W!!8b#Gccz9J#0^A}XYf=1&jw-$ zy`!Z6cOYdUGOzyM5%|#mJA$PYo=oe?_5WDzq(Y4UcS#VP#otX#djM3v*0hlRm!S>h z=>jmF-CXEo?lRU(bbCV6aMk*MGT2TA=gGzNT&vHZwbQ6=Pg+>g|JI&S$24f3q$T|3ABq5l_=68irjqlitFom?*8%X(6-)L1v0xbbe+h9Xk-lGcGA)~$oyKnz`-VmndlG4bv*Y=lh~yrI zHa(q{qv6@9segBl{v%j%8AS=>S;Lx7ZD&G-8Eg_%|6iE&|GpLa{}AZ74vJk2<&FV| z<#4Avt8U$hQU4#x7r$ES|COZdjs8Cb={c3vu`}78w-%^n@a=T|{vG|VPEoHpgBS;P zbzDpOe;8QxgWo;)Y3Xv7*`F4N{x?igaC$rvGlQS{e>}C%NV?7zOd)UR|GCKX1p3`b`srA5 z^o38Of#^aD27*`YD2eg^EMnCE&f2EabH>tx`;*@>l56jw|A&*(Sr_B~T>tNh45|O; zQro_ix+A9{T@e zdRB&{?hGEe{yzn2-XBSxjr<>kEQkJIgfyRyTrWhzmm%vr(o*&ReuNg2C-nbe>B+U6 z()&XZ_5T4#lQXrqrvDp@`hP=Nv(^8NZRr2w$rt+nDliCl8eU^D?D&5z*iMGpYm0HY z{y!f&Ps^HG)&Ccha@kwZ|7XGBGg&QMot={X2dj|xC;fjq>zSW`YVU$4hp?uo{=XSM zodwR9X2)ggS*Z>Ee=Hox_5Zm@kNSTlCEm$;@Oj8gKK@^bemWnxozbNC!0*Y>=LqWC z86B$rU&Y@&{5tDO~T`R2k+JYpQcUf|NB`5z88!? zkjDR?%6>#2_)_*c%6j%FWeDbu{$aC^k-AuGc*QSn+XoX=)LNu9nk7CkdcNozf%93OI^J){a)Vm#NQS9 z8b?WsNDKX68fn$q5X)>tSB?dPC29PS>;L1}6|(@ne<-ydhkqEgmGu7txH5vclal^F z7;N`I?hgcFC-lx<^q2jTR#E@&2ImISFLM2VIC}PYWN&5C|NA%V|3)-lXWamB>yxzQ zD70ir|DT2gtj=x+m(c%Llcx#(4&$euz9#!9?J3v)P4vEx(t|HXHuho!a&4LZe>Z*O zwCuyA!7>;d|0 zZ~Ezu*?0LpmfeS5Qvd&m_W0EO6w>_t?8ivZ^Yq%?=tbrF|0-yGBl{u_qqkf@%Dd>V zW7#8dGyOvSe*xO(|sSJjHtX0vK;j`^XtD z6>|OmXHs(g{~^Nvq_ySx|87BXg~HvusxhSC`2Rk5cPC|Msdhe~NlL#$=g0rU3j?!Z zg%yR>*?@xje`Ue(f9U_$pwjb2{r@KWYeN6eDD-5<&C7V;~7C5R| z!*l)iY!mW*SJFS1(DO_BXAQWA{#irs|I}O1KM!XA!;_|8LHolA@br0}VqfCP)TI#m z=U3UQXq)-jw8A^(=FtF!7?*g6)ZrD(Nb$m#m*X!`8R>}N@SK8~#1 zLm#^bExL*4=nYWq&)MBb`F_y+JX&}UrFWnoL$6G~SLd)vRr4=Cm zi+u*>uS-9#!t3XGA~jFR(=DZ?)8c1NS26Oic8Gi}z6)vY0my5#gt#+4b{d$+bn{ia zt|=l?%x5lFqq-4tO)M-NTH#`^LCTWi10(k+h*z|&<@%WA#23MHoNZ66Dd%{aL(GH@ zsziFkn5qlxB3!!W`!n2;(t{GT`G%E8Tc@jLu^Y?U^OZeU(`=8miMwmwT9;kfYUwP; zeK@|apv^d_sy$bmQgFp}e(TX<9INQD%Pd;jC#6_ZP@}vK*X;arUD&@^-?R+(JGlN8 z7Hw?;ro|gTTBOZud9LmC0}rjfeankZ;o!S%&AD%kl$W!?)1Yi{Lw?4-lb~!#f-E7p zQ(j4wl=DBR6D0(Ftw9O#u9Qp42c3k7T^{nPrE>*Tt_Yj2hPvM(_!`nG7laM$EGJ5m zhQdlYV{!@*Y<968=K6u_r{;EVh}^E0e^*h><)4&rPeE^fA^+mwxN6F=1 zI_2^oT(-x`vs^Q_#NU$C9PTx+54tj--02JJ>bqJ)og@yCE975oAw}(w*xx;vuZ-X5!YG{JWZMDRO@}Ki^&*$zM0(UA^xQ ztQ@xP;VIV;N>%>d^D=_p08$60I@|+O?LsO-{zo$|Q~t+LLdd`C*s(g{dqN@q%3!|c z9P%Gh*@ql0o$~Lx*DP8%mXWO%;vU2dO>NO8?>-jaRdKDyw{cye(&9cGIt^zWHj)yw z507m_{wHGrD9QgU=0>j3D*vtyDNR~OmH!s2kM!{X=BXge=_;2UC6&WO_@{{#8{bB z@e}BqX8)*@6 zmy`RVVz+@1N|I~{@ouC z^6$ENwQHcP=)pT?OTk6?Usja=Im}9O`JY1>^SPT#{*wI9hr?NsDy_@^Txc;AsAFiG zYfuM3FIVP=QcK2stH5k+U+kZ|GlxB#*+n;eW%F?2ccI0HCHdcvxYp%=0khr{C?y~N z%woOj(4zbw4V?>E$HrpW+7lYD0*jFU<>blb|KKG5$B=6!wO6~-nHwzO&o|@_g3inM zokz~K;2H9NBo@=f@csy5jj6{{r2d~vUgiHN=-ZE(X)o$;DgSC7pX|=!M}Xb%q_32J zcd-p6b^ubM{JU$d4_7606dYFm2UEWLXw*|ao0YFhC)8kiX#qJ={wE~4EXn^!YMOx6 zq6alkCr`-#WO9Z4PbA%)Bq9IGVx^nL>WT8dl=;&k$fs{1?v0Fu{7;8+?zGs6`|0pK zT0mWr<;`(I=Ze;#w_wb%gOiADW(=KE)3*ZWxZ4Pxtvsn322 z=I^7~ojXg0En?e4!QjSEF@@$BU8lU6GVU@OU!#_ayJGN&a`F?}hxkV`*1p zN%>y_O}juz-?dc!$MZLfHdH(1e>w8MBU(cFKMbj8Kteu}PKN%Frt^|mhmr(m~Q$_m9HwDfxH#y4bF73KdDC@~w`$_AuxI(Djcpm!mq zUPtH(tc&XZYr*eoTHFg6zO)*BaJwDcwk7%BlH~srz$*XGQ|d>O{6EX8hp;b##gDPJ zE}_<~*d*p>PZj0=G2kD8Pw#F~{%^2d-G=3t@lIhW_MMRbTkw^C?YJfR?^Vd<|BqO4 zH^ZY|1?B(FWcU45E7F-|yA+-PTlIg)|39#T{VE$oj(p?5FeO&btV(I zN*p3{uwze(-N)I zmO78D#W}+a$_uTvLhDI=ip?>UhS~(e*%rt1LC=oraD4A>d3T*V#|TSW%rh*d9%_CdF!T@-3Ht?N(Zslz$~8mw#uDa^E?<7E3Xg&$YPjj4onc8g@?QU)x1U zpmr;Bgl)_gIirlXeL}7}szb|ISVgsq_+F5^u9ScG`FggH-1iNooZbT{-`3P7{|$_x zr04)(Mlenv%$=NY{L_V}qq}f*CHWr?1|z7`xnRd`0OPNa|B;E}LXV-YT>dS^oss=1 zQ~4iCx^D{QbC!;32+OQgmnzXK<+8RlZCX0-l_}*ws+dc?SBtYRO6}-d(ng7mw_~-Z zhwV#Cnbt@pOzEm!{`)}Zp0qjSU(175T;F`rR-siUbVJC$?{fKunRDsd)vTv+-64bCH|0Ai-kUR1Eks3Cvj%YN3v9t2;JW=~c$p2{OBccCu`FF>l zZ*7dH_92XGecP%Qr)6wXf^1+OIs?q6LxWLJM){ur72H?pZW`s^8m7^r@nBUO{xg6H z`FHpBV8*l||Jo(SF!t%sPkUme{O<%!wQ6{R63!*3 zR>;3IpN?HEll}W<7g{0SLfv4v#Qhw+KF=ccmMwoO7>JS zCEjy+lz-p4anFCQj}i)PUX=eav|OvFlqi>f?Q*{JG6df@_Oxwy4w9!&bw>WjQir?z z7lNJgKM#C8i)s+_#gP9QVBiktosh6OjBNXnTATcotu>>QO#1$d`hPN< z4*6dW9=j&_U)m;3$`iUUGs@-vAh6qw`Sd*CcP`5RF39h4M$prc(~KPvA^!(5ud5CJ zT>e)u$2|z#PEGQ^fLUEXO3mf}V5HOMV*wf-h&Ap^I9!|jAH*DCuV(pQndJXCO6bbW z;dH37j+y<+B>xvucO$JCNDB|8mfGZhG?@5QRsNL|pH}X9_W4yHq#KuFe8Q?EdH3$p3UgV~L&1FPDGMcN^1Asih?4e+ArHLCG1` zpWV?2bCH^!aCkA{1K{=^_$B#25POijrgkb7(oSdq77FG6cqqD%ng0^%ISbkkhr@&5 zfbxF`GpniOQ~pn(t!KiYS#ZA=r~I39B(x}(|I?W*PJ=e@O7g#!I*(`Wo*}Es|7p~@ zw3gz*?taQpub+v0&R}+ZZ<7D(v6wV4L)`@l`f!!}pFmp=W@k_>?gQBO)c^Mt<^Sv4 zokxk^V4vt=>`?2^?+SLMd<>4BMZS>#@4)NY<^M74D$~IH7A#4{otN@PXpWyo=mAxew6=% zXsedno#5f3B>(P^D#`zGN&Z(NrMpxAK>GXsQ0t&t$WOjp{*R^CAHW`;D_W8NE0X-L zL0X5y+gp(TQ)|Ru`M|92xx_hSJ%i@m|uu(!zl%F6$faO7rAdQ$$si%sH8cvGwV ze;NzUFKFp!u&WiY$vj5*c1rq7_Al%@k7m6Kw?K8}|JCgGq%Fs~@-_BKbyof#0IPpt zz1ypBV&Nt9|Ml#1Y+zT>Z;JBo4(11-`~z^hccFIqKM_ifhnpq&SyhyugR#JkBW*mk zo{*ojX~_Y!MENyG{rMu8-GQx2`rMTI z*D7?uJ@l_{C;Hq`q|ZIH@YOQe}tmn|*~EJ&Z{vx5rfvhV#k z_WeyPytgnvJE0(bPA%BK`W9*_UyDUpW+Eg^9+SiS1PyzEHiNj!bBEo)IOk4UpR@oN z3KzBoXJKI<2pd(LLl8ME$+2MAuFR#4BP>SFaGVYMGsV?Zb8F9!@uMsCzQLcLK;S6E z8JQzFotVY@DUJbbS>T%cdHXHhvW&O(2=~vu6S|4roW+;}}m&<$02~ z-<=Kfh{@Y;udQtVY&6j>JTs#GW3%z(n9Xl4KkC}O9jR9D*@=eg;76Pn8C zr+b1fZ~t!S)#2nghV~zfcHF8L^ zG4BxRO6~WAlc8YNkEe$xoj9fn{+HT6m-g>Kd*)QMe*u`!=kH*2+zj~d`PW`X8zNSFs*cKxf{{i0W>BrS|UtHl7UQ8^E@I zcc`;dbNlBJ6a3!?D(;xxS)Id}JNSPDbzaGnYd-jY6x?n9+i3qg7)R(nQPuv3Y5x_> zU~c0nud6TY!fMqp@Euqf#j4H!@*aWh-&~acpCbQP@KpZ?Yjk@RRu-leKFPD`aPn?R z@a`&DORamcf8fl7|G`k=-LyF8pZKrlz6X>O|1Zsk4`Fu{xebAedXoG6P3u*y>n=O@cc_UYr7c+FtxL;}yRFpTu4Z`7j=OtnYrplG z+dW{R$76NFy}BLSsN<;`T$BFse3hQHtuP3g?^_K11t--^rBMc%+HgUsc%H?xTK@Yq z^C^)(rP}}|+SLc?Ew(<{wG22OkruJ*v29pWg8$mrVoW2nyGw)r9ouNj`5!yTe17_L zcSl-h_}_qzbZ?q-q~L$w;uxU47PzC$@x?IoQSe{=?wCXVcWgtFV#=UnC)bK%d=Wd; zYq7Aq%QW~OJNH}(k{6Cr*gw!7>M1Sfzhfi6Z4xKfX@%74*)jhe(**xL2g$LCs}TdB zp(ihej%^Q#9%;0rwcOpuBY}0llp`Vgf5$c;-%l}@@9p;nTI+W3e;8W1V|Z!r=*0Iy z=R>)9JP+mnR3vj+P5k$~hv2`Ktnt8%;<|ueXZRoI;K@nHSN(wXM1trY?a|L?ue)^B zT%NHq7+=f2{Hu-so`294n92OQfwkwlj7sp6D4`?gDI{7$3ear`PtWdfZ>Plng_Npw zzI|88|2-L7%%+6JiT{%sv2^6dViDMnOnVjiekmNc3s9{AKKKT7&i@I_1v+v&Qjh#!nD{@3an`=jZxmzcT^LjD*bz7*-JJhtP|g}G z9mm1{{lNSjNMO9|M#^IOzJi)CBgr1!~dTp{(pz}goFRz z>JWYxw9L>nE}fnDzo41_j-Wf{|Iv&$mlgTH1pc4M>}HSD|9wmT@DA(0Jn{cX-j1~Y zUk3kgVf6bptgKhp#Q%@N|94RD`Rqt4@&Ak12hU;U;wK%}e<*X6%~*s!UB>?hnK9gw z`2XDw;indY|N9rF6w3KOy1>q~!eNDu3fP5NLD2u4v}^IAGWs8ZTy^A*#u69wznoSy z73qI2Qe7MUClnrsZhv9dp7bAE*iOsm6nYn=|8KFTcH|yO_&e_i{Qm;?)E^%~3ckng z!j9a~!aBYJw;lbljM-D*|F3LrLHvKwhWwOf8!gG}=rNqLh|*mN4@Wgof=~GB8HP_l zpaJ4(&m)2T6O4)}l&hi+qnR&WmgP37lKP zY(;hX+NyHUZYe{o5mX^4fmy%iWP^ z?V&uy=FxuFLYJ2(5?)?x|0p{&~grPlXG!;Zw`@ zAHk?G+J7idlZk{SGw~O{zqW(noRxYGv=yv7qaehcM<;w!2dIq$?Sv{|KD)F!a7z^{@Mcn zDF1tu{|U-S$LM^|ZhIJ`Y8FDR;z2-aIXbDV3N* zM@n9HwI8LJx8zD?7}9zZzB%FvSgK83Xu8)@Y}}Xhq|X%p%#r7g=S<`&VO0v{m>E;) zd{%`W!RKlI~1J2&f!O zOU|9vx7c}TS(X#Os5hREJ~N~I5{9Seo(i}8lE%jfO+?pvY7G;)ifPX{%rrFxf-8Z1%h zkb=_FFEDF~pLyL!X$kShvE}AvYMrxf)+3etbM4PMq+RUl6v9!1bO=u8mOrhbwo5CO z&pIil#V9B(HvWPF1k#;;xpQSsD!bQKUT9ks!Wc_(FKawSW9Oi2e&%xzoUMx;)L|(M zd!TQrifxPz#V+V#JK`;9Wl4&L^!fH;+b*c5^*4BJS+UAxi>0imLuzOA9Y}H4<|6h| z)Uk~C#t!V@rzP4hb4Y7j;Ev)Ljk&UCd!>GikEC|AAg&}fyU+#l&2mB`n9COW^BS@u zHs+BF#`zbTMmpp_V?z%_zEbarJ{q-@%8&AL&bGu)$u~B7K$IpIgp)s}QZKP_Li`xifi=Xu(#TOEIayDuK$b;&IU)L9Hk>D7gw@0JI9c|5g||1EJ}^*p@!|# zVjW-02zrRKawWdn>s-6Hu9){oU+pod}8Tbb*joU<+IXYb7QpY*V& zHUOu-@a%$I|3z<=4)KPvoN@=Q@2`jc^AzrQ=Ur*B2TMcaT%9oI5bit`+;>r8UE7uL z;7D8i)iPbF|J=VF`p+-EQViqNS>Mq{~ zuno?2q+Gv*CBar)oORv<$dPc)bIPS!N&k7~!$?}~?&MLV`o$1WQD`7mjpNr@hjSnL zZz%CTSKS?NO6+xThlZ!dmh_*eWGhvk9+4%RbzAhy^=p6z8c%X1I(lU2 znb1ATwks_8&mJ8;SFNNxIs%cJ_6z&5AAPr^|KyOeX_}>( zL#fK2zQK1(^a-KfQHou&ag5V_IUb5SAVwa{Z@dx$@!8pMK;SgoN6^;;j(B zSL`=D#8G**1gY)G;)9S#ztADRQa~5i6f9nR=RoOkSH8PjV*FF6VDaJ`Ra#5+waEEQPzNZtgDJrgi04jmf+=ma z9l2G}w+USJRO@*5jZ$ns4*h3;=uZjmnu{lyZ>)GSm-~wBkFHny)gkw238jl`3KlOD z;GE|U<@#?Jd{AcmvPK4Xgqcd%Z^ihPiqL=B-gLeJq`dp(jltiQa>jmFvIVShpR6)vgZw-9xwp40lL0&h_7}lw{AI z48I-!dFR-rQvV5ENIh}}rKtZVw~60a_Fv7Xt$uOGp653nrVw@yeM$fAL@xE;!C16H z|LqUd9+X@FVl2Dv4j{)g-dON^&Fa5}l%W1Qg19NHFir;(_1_`H9RTJ0UeCX){|=(ROXJBIs`{yPe5sm_!3vur8&*#k@ZZ!d6d%Xw_FW~vOQSv66QArg z@g*H)tY6CK-q{#$hW>L0s`}5-g8ENue0-m)3pw3I(E!{i;(hYO_(2M`>>q>3r%urC zg?u=o@M$!GpXY(8Vbp)VFQ@+VYfj>5uk*dOa{cEM*w)zs^`GBOD%XEn>n8&ryjA~A zBfWk7w;#RGucvqpRd;%QuK#wVrs)Yg_1_+pv=DxT{+o%EtN+~3vI~7_U&`o88O{TI ze`go&{0h`8?#8lWyaz3<)PD!j&OPW!hrn_5-|{y3doDRwV&zx=oj`v)8BElFC!mv- zLWljqdO2z8zx}CAZmcBtNywA>?<^pefyoeJ_CezOzR5vF{kIyK+y}lNgshEWE%Rtf zIGWNuLFz0d^<2t3j1rIUK>uAp`6c~#2ozBNorfiVZR%^MQFd2icVpdJ{pYu7JTY7S zcM(=_HCQ9G?ZOD+LPGmPk>lX+oa#y zY2AE!+1r!;JDE2tRwey+JL~F~L5*?r(sS84d^h+W#}3!MiCqtML;sykx%U9O4=1i1 z#Cs~AM*2R=%EU>uU@!ch>S(q4oAq5mF(F85OYD)NN>`&QC_ zFOci;3jKF=(tr2x#?fuG_E}2G_1|64^S9`~7vROcyrq)y4%<)Lq@PdInaE8&6rT%s zCW67PN&ophfx$>pcVbHVZ}-%z{T70&Q$3Ju_2f|UIz(`fmahchAp4 zxH*ZOebLK)Yi4(7ul_SWG+$iHDd|^R`a&gr_uu=CA@!gAY6qxx6lE_3NA=$_FjxN_ z0PQ@RZYkKS|CXfj-_Fp<)6Ud?3zPmkHt9c~IsGYjAh`9RCdV#^K$FmayHQeKpxVN3 zKV&uZ-&NE!j~+3Kr;($DGmw%ggmeAZRHgq8r5(N>c{%#;{m90(>}EQNUT`2gGrF=r z=4|$PFQkt&vR=3Yl6(Yhbo_TZI!66>9lh#f*?91~s2%9jPfn;(|EVEX zQOnbuS+zgEacQU2S)3>IpUwL3qixdfdq{g7=OAsRPu#UZ!^ z{WrDnH{Kol7y9ow_V*v0RyG%c)7Zind1I_lcn>E#&7-v&pl(V3&EX96OQA>m`tP0e z-?PcL0xf(l8u(P`vMW+Nj&~63zo#Qz7pMMvGScNapl2bO7xIh#yAJ)m5{X*Eit034 z*^}oG*8uY%GIK5E zKLm%O|88P8-EHWuO{xE`;=Ro~;P*N7s3q`e0K4uk2gAEl|Gf#kPGk4fVA_5sy~J;i zT>$;oBFmdn|9u~Ej$d5=?h91g{daC*ITF_Zm%4Kbf2sf0^9IIOv)92Y#xG6i@cYTv zHTyb!;7)q>v)PEkk5d1gTlfU$c%97~p!VNs+|A@%`B8=Fzq1R`e;-Z#w=2?c5ZZip z;n&%c!g%l-3Ke(WN z{(DhBH`18%3*$K%ZV+$OY^EoB4&4C-`MXEq0Ct~Y+bHDxomN=FPPzfv(S^%d_dlcX zW9WJmbd|r~hrg#n#d(E4CI0SE_yXm;o;4KqFPulc(>QZZ{+>~2i++%|=v)bk5q5;~ z`1bv}1QS=`b9-_7P^DBM11fCCUAWUO@>ZOqoUrv9s?BMSj1@VpsM?QR3kqu0R)TBU z;;X&83*q_{t_{{vRA8O2KZQM8drhs*7RQ>dR=aouC#YI$33p|8FDS_*u-xHr!|_kp|O(;5DI0+3&AEa!iF>vh%b(yr@D zgf__FzgCOtU60jJrTekK`3{EbbJ|q2md5+Wr9AD0eAmYJTs%M7lh(D>XqR~_&USe6 zl&5{y>U>vtCe$0l$j7yg{)GI_aIJ1I<1AN;x-b{W`R{5-t!@r;{636sg8x$~Wfb$6 zDYb$#Qq>;hiSMqkOof~7iLJf=m-s(1*_#TCF6S`MtJRHV4krI+g2j@z!2g|@%k{<9 zBmbR|%KyF7{H|6EO8L4nLmbZ>#nY~9by`+tvLZBwF`sAs^k?R<_$~5(0ljEG{eS;X z@c&dsbxRZf52F7c&j^1MbKdG*t8KStN5)a37#9csPlo^6&1&cW0a!PdLi5AuH#;zr z^s9w)7>m{FPG$xo|IcPl@z(gi9{x8m+CGI5Yw&;5zs3LC;Xh;28eQ;z6Qk~XuuEN& z-fq9Kll(uES-kx}=l^Fq!T+x_*ZmayzmS>IWz4akf}4+Xt<~+w7+?P1koy10%<%T$ zE%Ms=|4fnpUt=aE{~zik|9_tSs>uJJ!o3e;^HTq7cdO0qoc({B|Blp4GnbgZ1m*JB z$YESQugPKbt078pdG5$jDkTAR;v%HuG0XEWpItapD%F;UEjV%+GEWZaozQul>3L~6 zbof!K=^Z;~Jo(Jay1b7XO8XI`p2!#YM7SLLfOQ5Wbl?@(Mw!l#N@bh-|JI3%?TA0i zcYVpY*mD=_P0_XpyJN)M=FQvVT*|o4xR^CspEX*Wv!~co6c_|mN+kz>qwd&eX-v!@ zoqa}}Ww=|)(&8$fmSWyoozP=wdvW8vFn1VPf6Tv4iQV(k*f`s4J8XCK58L7#-#xsw&+p@W11Vvfl_>Yv zNiAi|80XGX(>b#i0PD2<+5)7K*aQzlcD0ZMPU05)cGl~iZIchK@7C%(!AmID!Q3+^ zM%J$62Oe_7SaB0`c@#T<-C^jgH>A{E!`5wFl;KRY)PJR)rPMyVl_I?oChlGrJ2A62 zh(YvP=e)6Nu@AYWg1G0JLyBr0v28(rar3McSN`HE_Qv_nrL8estF!G&ik6Ew$IM;8 zp1);%a#dc)eecyT(Gqc$zn-%z-Q3wIox2btCZS*4O(hMDGlw<;ORF6}_f<(1rO4e* z(MR2LU_0G8W$$#wKkyM_Eh@Ij9gRw?(r1lwS7%$bs=6aI+N#wdLb3Cz_Wt4b(_ERc zO!sm+7tZyc7`r1NbdCAk-z8phDE5n~|DtC~qtJiaA(T(;K%OcmXQYC=wUj~g*Xm+F zvb)ej;+z}zr__+b*gfy5CGK!@ucz;ox)07e>w!{IW4E?6*T&^LrFH45y(-R})#jrX zwdcDl?f+i?S*!BnK2mpEyRR(tpZns%`s99X+v$6weml*bb$$m?onT1X4Z?SiUaija zK$LM$zl;5|?#6cSr@LsS>5znnawl~{|2h8{Oqvomh)_xYiC=y~ow)cNMtA3mwI`p) zHv>DP|J*Y<7+Ce6mQcTE=2^s{{|trx^NW63I|h;~_V@aZt-8l{*ptikpJns}o7fBQ zHwr!T+H-k~t$ltqfD&xw2x^XR;n^#dD!(b`&wcJnqdRxBAW3n*Wf)^7_x#vb29QIT zzF;s6`&MYaI5}SXrC$mk!PPeo4A<(^e}2&*^q=3#boY|`uX6o26kOt62yKM@*|($3 z(%t_3!B*LDw{_@0dFeOM{N|GyQ=4Y@bnkbbM)7CMwDr{L+;^DkKhMqct7ls4e2;hp z_wMa>XQBJCl{dfF=vx+kanchFJ)hBUEGV0y|H4Y00jpN=%xc?YTl~J860Gdj>O8A| z9Cc~=^weqBQ{5+S{Uf;dJ8H@wI{*}_1|DpyJLM) z{|x~@_lSFXkLY8H@Dv`^^1_|KTpl~yOMrMVHi|X#-v>jAe13@^9wl`D0%36 zE`E=)D|BV4l_sgmOrcy$!PK>5e!%Sq#orIo}ITT6^p`J0|>P~a@-$-IT zE#2=@_65tSv`hUr2^vi&M|X0n|NIU>Z{p@4k7~NP^a*>EJRkU# z2Rp|Xq5ozeEB;2nvq{LKUvuk9eS^6R{pW5yIbG6!a$zVX#&<0}ZQi|;bHIBTrKtZV z0nr)#Hy(&N)a%YAIpkTD^RVPKK#56UH-)-9b>8oI?nu80{pWtZ@#IziO<;e5r+@V& z|7`xIbH6ib?kCOl-_FGKWiQYu>Y540ozZ{3SD-{p!!qaBE7gCyC!9xcKNE@#r1ZgH zr}TS{>s;!Z2=8+JH=Fjj6WV_2zUn^Y8w*F(e>=gG{@7dRQ0^{VXTu-gD5%x#1UHvZ zN=g6Cq3-$MJP3T%e{(4+^q)J>{BF$*u%1QTo}!_oPN#jIRbfnb!k)uBA87TTyV#AJ zMb0J2pSz|Pbz*&DCf4u?tSIFAZ#gYj|9RHYVrb?*@osQ@I6G|SbItXi-|3C<--xvD z%yU)EyA#yf9SruN73#l5U^$CDIPS6w{kIP_{NL-pMPM<3wTXf3L0?X54glXd&{AFJ z7d3PJcM#NaZ+2lBM4p2DPe{+$xgNaf9?FZxx^6v!}-GJ`Kj-dUJ4fWrylsTP!M|<$MGgRE4T`!^k z4yRSMx<*QxM#;z17Y?MPUSPZrC9Qxe2Z8I6tgm#3Yx@&>5-nH%`6bk&sbBr){`_O1 z$1ccM=)Xnyep_)dIrhdPzLfUm`fq=Bh#9-MR`igKGvL`iVA749SiPW4=)c{;W?}jr z#A?qmXomg3vMZ}Oq5t-xp2MkS1!;aiUMH5KV_Er8{~ZTrOIW>GK?!H@ zH=R9Q>nP`FN;nMeEaB=|B`cuu5!9vrb9ZNLZVWvv*MAqYx={~o=)a}NPw2mc!65YC zDd2o0?;`YtPbK}ghP`6yKe@S>Ry5N0kEbo_zjKrRyNLBG_21c~t{~64+K?kxuK!Mi z@*|PJVYKj6*3U}%?_6>fpvKA6HJ6?+m^x;HV{d4s{<9ZMC4L9^b_R4`js82TsQ(TJ zlhA)}BWJGvE`biUy3l`{kYM-Zp8%i7(#rAdK~?{`@A@6kA@tunvsI*xW{=zftVhj6 zo{l4J1bd7xM}o&Aq3XY5*@d>AU1c-q<%hwYGm84}0;JRN-}SWM|6c!HgZ?`o3_f9Bq zA0@13eQO<9EM8u)h^_?(AiyN@ySpZn#nrf2$v(X~ncZG=v@f{Xg^!~Bk5zhUUV z4^ZZGc0KOFcMYzmuiVLQ?#sb%4gJ0|`tR*Y|2>xU-$&rz!%6?$P3gJ*JCoJHO8s{~ z^tlar?7{Bb2RY&U7XGe8CLRCXTGW3ZCP(PMPeJc@)6)lXn$HvHrMo(<|2|90*71#D z_22o(_d3e>D!lUd5UZU}qW|25yp}!8??#WjlbSxBzU6TrY4`AVA323_uj`IT*tL{& zL9_n5i*`IkNuMY8eO&LUwR^A^@dkRVJFG+h+3FWs=)X&n{&VMIf8=K{62CK&_x+^* zzQ*p;`_X?774_e(N&kHq3SUS6xC+^PiuRWD-|d~$e-A*BsmR_m+Wz~Z{`)*QKZ=(4 z9KG}&`r$(8@oA{`V^)KYWFKqjzs*p(4te}Vv;O-L`)7ZF{`&~$wCDQo3fiRpyN*_< z{~jmLuWP2?=aF5|TY`$Gk?U+&5Qk&NUP*ZRXe4857~~^KeQ`d2>7h&NA9^u4v?cmXoi%8Wzg6=BV3s z2KY}&7z~0ha!_bMPs~gr?T0ag9#LYE@wp^_BT7vmX^wGK+YuvH=>uO%K z(>n4$!`5#rT6fyLOn1F1*4D(_^()ITCh)d&V{MhIa6z?Lv$TY^Tuys^S0uDyTDCR1 z#_39qt2MFykkdaboz@ccZ<{_^OfAn<(OC769`a9UQ!Uvw7f-p#TPog$wY6!>?#zmy zxm`DKMN7PFk1Yx7t?LKUGFqhN%JFa8_y0ln2`*eCsac(^brn&)BQ&3Y9BrxqSNd#wasN_tXVxr>*T1k^WE*Zmm6(4<;8T@EnFG&{hv6m!j*tnJCnB||57JT%5b&R)`m>g zzF%C6rnV?Y)1GkwXhuBY=1pa|vP)vqqhN<;o#P3cJf#Y#Jw>z1Cb z(<{wWJ;T@-cl&!rmGbXn(DS~t-Fwa*G2utm1`~TmRJ7$;@D`)bH}=Gh{yW#K*I862(^u+ zZ0}vMYs-xQAJ5mBM45fC^o9J7g$uz;&pvS-Lkf8kkKY3u4-USo>WZWC?_0&SyO96! zU^b0Xw08AoZ10&M1DGw0p={+}i5&?QT|I4I{ypiyZ+A=tVlp#oIXElHzo&vsW&Yip zS(5J-l*_*>rPF|MZLBZwZ8=*x9%}gYD&=1*Ll5RHp3~&nFf*vnZ}^U-9iFTb`hOzr z=|ybF{}dqFa$^(Jcp!867tb-&=ouBW;qCzDyPn80iy}PJ$kmTA%(!|`r*xXsq5RLn z)-xGg=F#5yK>4lZ0ySzs?nYab|DCB#tL#+fk|F=Il3dK7&i3@b=a}q9$wMhw`Jckw z6zbWP`S~!)QvT;r(mZTO!?C+4|1+p>0WFyJ|FHKS@KKc8|NoRscGH%G-jqdpPpAO| zmLN@#CJKVeLI@CrfHYA-7Qxy2J}#d7V!@AEm&%x0c! zLb&&Pf93W6GccK%=Y7s|o;GLBJUhFCexb#tuvpXLjsG6#hk>X!$A4dxS&e`GE(PDu z%kke9eI7(9!srA3N;H2Vx;>8h=C}Qge}2O~4fmb=&Ff*vPrXl=?`P%j;xtD-9RHnR zy&sMSV-2GZ8XFPRh~uC0$-`SH-Qf7|hgrgg$jKZ3ebBcPu=a!fA+VH=67c)_)h`p=@jn&YzL-}U zhH~;(fH@fz^_@980Hd@C2Qt0qgf(6pXMKb;; z!*)0H4d02vUl}<9vit;O6g$NwE@=dIfK=QnN|VZLi6=9O;7tm0be*R=S@|3-}G zWtiETgHLi+VBX;_>9-*7+Q$Eb$f+IrY$~>WF&n0j z|K~6#oQLm0-<2Hye3Nf?oO$&B52CfUf!wg)@xL`?{I5gXpMvvgBkDr`f4_|XOVRV^ z;MXADM}5@zzX-jq#{agOng_FwZBg5NjN>hs-@OcH+P9d6d=qu~9IbN)KG)#)^>^Vr zF1O-0>F>n%(jSF|BS3rLTk1FByY}zwcl_^6j{lu_cO%FDizwgM82@WAT9;$o?ve5T zYI6L?(FecC`2PS_emFS(|DPWJoPFRwb-!7;<=%lTlv6WC%z^*BSsw1yzVOac+4ts$ zIE%&91JU;KSMx;b8Gcm<-t{u4+7`-HmY;J*Uio<+TKmHJ0Y2%d?&Q@B9OrM;y?yQa zoMB=8RXI2-#=949Ca89O^<1{P17rNfJ8s@h^6u=wTafnEGryc`VQ%V~zuN7qc|uyG zJwEBm5^=7r=6hOyuAIeTsd*p6QqZoN`{JE%?TecI;tUO+M_28yes7!46xY6RUW4-u ze11~RU-7Px_lQiXec>o)gg|TTJLaUeoZqQ^;miT&0#yI=d2&7<$^Pf_!?iD}|M_e; z%gxx9vm%`3;C-MiM7180`h^Tg`SKz!bl{m*B555&Ief4=XN zGY@>G)$4yo*0nFH{~Nje&!=ZON5S7!KCu30d+{wd%|w$kH|kBGd|vjz`k%kNt@@vD z66G_pyq9Q()C1|i03=oa^Z8l!KflG#{y%g-cTJV;!v5#C?)fVOe1?wCW%B7Zew)7L zsH#$5?Wz9f{c>}(0Q;Zw3vH{4Rdd`*`k!~Me2Op=dUeo(?0?3DwJ({ti|3Pkoe_)k z`RiO9sq?=*;@jGnFj^{rnCvjLcWdO)4(0xL`@b7>`$+${Ku$g6E~g3ZtPZ^YJIH7& zK-8)FpW8x|srIFv^nVALAK<&Zz5Z{9{_k14I$}mXcXaiz9QuGy z#7sWm{_ijSKL)ktuTM5NA{c)I(Hi`1x!RVI7^Sn_{_lr#rW8+MlwstLN8~-UHf3-V zp7vObl@VwG_WvZ5J59C+*8luHEIx-j6K!AQ>;Kv4|HTJjpHF*D$LIW$@F_i?ylRCz zBL1%1aK!xw-v6r+$#+3KUyNsaF2-IIZFt4M)&JMv{z;wxv+*3sztjJ#-2Q(MPeaYb z`Op5Jh5o-E_ZGD;=i%(XDcS$eKxYl^bxuCu{(k_!vNjv{V?6))y8)%REBXLW1wD>; zH{M&jd6fBlxBnl+6Ck%s|1Zb(Wt{)~ZM52!&(K<{(ElIfd5tH~@)zNk$LRlOZa z|JT-f-aSX9oQYj^KjEdRBc`i66`hlMcPfmRQ}wCGE4jBa##FhHc)2ltWB$Bn;5FG> zn8JUIi}^V&b5S;w1g$H|_*va^@RK}mVI<8@U>Vn|*xtKe@+7!ru6%BsDNOJ{pDw#D#qexpk7;5>NDEncaRvt@)w-cXL6M#;HPzr zaQPV`=dt-YDC1Kv2jRk6KHt# zXKdLB_2IXNJPZ6>jh0z|eon-1R{8U{q0tnPL>^cxxBm5#+Q>+vM1TGHZ5S_izN3Nn zGOgYE^S9G8kxwP(FUa!^BL4b&zjn{u`F3Mf|8A&%GwAbME|vPZNa-#0=daZ_f_y7& z1giS0H%>IbtTMkL!nnrEf%Wf&8MSQ008K##!1Md__v+92=vKHc^Ecf4B(+(>`dDkO z{}HHfA6!#Z|4)$8`s+W&t^Y9eLJ_2fqb)}J@>limkL!Cklx-~H6utf~>O7Q&`i{{@&~_F9MIe;V55B(%}-sDByeq32`X zw34g(pNJfbv2y&+_2q70W_JdziJMTflaUwee+jO5mHJyz|LL%Q3rfLXj2@2t+kN~} z%zD?u6?Plyf3vY2bBt@W{uzPiRm<>1GM~G?7f*jyt^Zoof3;TsYccoi?|)VQ7u@e*f`kKFJWb9rsXUYyJ+OS#RfTg>YF^6w%WKVnENXs+lFGW8 zSL1%w>sa-<@$O!gnqHcF^uN4LsViRfT9v74UW1>Fvj*xZENb(JCGc9cQbXV4wSw0r z&Pl1KGH9JMJL+1hOQ#;Oyqr~1 z%4d6cXU$(;;PXprwygI4<9Gep|D0uGi*de>zd^v68ZP@k57ZMryk_(1Bep(&A(QoH z%uxG6X+|cTP4i05C#LvI2z;YfZ3~~+;V&Pk^N0OUtNgr>dDPzi{Qh_YT%-8(3-1;A zO>)kVai)%cYg-tz@F^|YK<#bhS=+*Q?=(Y9#s2S({yzlQan=8=4ygb6G)iab|JK;5 z{tqMK;}aPz(66=iUqd{<&>M4VHlmkiC;{J#uKK?dN>Y3Ow?m8b6aE3{y#Z(oM#9aJ zBcES7kZ%F<=@))uh5cWY?EeDH?G#FT)Yg7|VZF1Ill@=h_J3dO_d;CRwKjE>wio7M z`1|k2O0V}p3j6;c+SJiXmHj^p{XZUYqU!%i zh&gM1F2u{Y7oNtb+W(Ug@f~>opDO)72$5kk=tZUf$Kw2F|Br&1{ri8f|5u>@SKyQX z8K?pKKZ=?y_X@e6Z9P0Oa3W@D=D7Vo5%rmY@i5egq5sG3M^mBm(f@qP!@!)BfzQ_` z;~X&X>H5Fd|69@jTT#=M7&GkuvjP(uZzJ={=*j^90R@iQW&i&Zu_9kq3y6(aLRIH^w zTS(Ry6Hx9H8ntZQwu8>99PNPUwXnMZ+nw0Hfc1Lpzl8M$?7xilM(n?W^>5gJ72DUb z-irNA*lxjgH`Ym5m!e#lbdAw5Y{&XB_D^sbw`aM>tPATw`9qNh>&j!+si`YJ9$QQR zOI|Cm4>{(AmzgM8*oYM)jd^m*m1(O~n%F)A@*g10wG%rA`&=ihRqP@^(LED-u+RLA z7`C;xG35TYEE1KY1G!~CBI3qh+&9@svn<}cnmAH>mW|s3vbyyeG;G|YX|v{s9NHp$ zSgSVe+Pj5&49ZucK2Ks@hyACqeFp2*Sf9h1jkG+hyHRblxv?H;4X_S@KKo)Q($I#| zo=hKwl@kc;hkLMMtjgG=%;}Kj*hRl{%u*&c5-WA6%YIFVM+k+@8`}Jb%dwuTqDa&mHv3h;H7&1#-d5nYV7M`!@LR%`vNt698 zFT?I@SkZ4r!mZDB)oi`~WPQoq^}hci?E`OGS)GU<=k+OePbCt zgp)3V-i7UIY-d7$4ffB${)yQC z9qUQ3u@CFd*uNdyt=Qg)?I3I;*cM^SwmA=LJLq1FZ4XzUXu z{!na3yDQQTbio*;A3?@)>WWjrDU8d8g^43B9G$lMFO!j!t!62b z9OL>fu}M2@hu}CL>lmyI&9O=vj$^qvZj3F*0c9XBoOyWMFV7f>^2jrW@Rl)C>@=*< z*N&Oya>>s-_Uy4t%)c6afB9G*)<Qrtx$fW0m@1RL9(vX*Di9 zU*sahYh0QWNO#hMf%ITTMj#_I6IbEvtgM`z?Cek|CzM;KPMy5G+}yhL^6J*BkN<{= z|LDc)mP2qp(|7!da{Pt0C5{=Va_l^g^eI?}VxRspj{O5&P^Y>L8Z~Lwa{mgk&%wVz z-gTkyBep-`m_D=_%JB>Kf5Sdw@Gw^RH}Q+`84?>K9*MQa%4=XbSX=C8U_XSF{ubj+ zu0x3BVyqiF*U5YK@ zNyb@50$cjqC$Z%@j#XmLe_(qL)(??}yznT!5&H<+|6>d4%*EX#w_Xa<(}GzHO6%2c z?1ts7+lY?;&&4P=uLHMXdlj}}9#&U1*@*viR1ufj;f603tT@hx`tVE=opi1Up`NNbFh z*SZU_;`$|VF|XV8!CAgyq$6(NHC*CV_%OLQn+^uQEwSUfNP7<}$HQG%5eKrJBv!i$ zTecPTSZB7?EUf>n#jPfLleIf&IgJC*RUFX@atFW%Y@!8m(i7o0SZN#yUdd0e8n~(KBTP&#IYLkY`PGtsey($x` z+xrr>zrxDr)9)|a}Y?Jy}T?JDJ98QLR_ZOU@F$82|Lf3hxESq}CG z?XcakDBHXPMZ}-x&6_Az^)Ifi#kgiqf^QmRjKV0y4{PG@c&w8!Hiu#zk8_DXsyHb& z6*VqO8SRoKLtDAMz}J3IZxq6{)FW09B@wYF(GFVtF#mx5#Z3P5RNXD}g)0nZAjp$RB#G!OmyU{!#=S^i{2LJ) zfZoDO+G3H|NVEjc3|YJkW!nXwx>>9_`lKcPb(Fs?W1V6xq&Ho8w3Qdo9bU76 zyNKkQ@Rk%7jhi%Xkk_zocD=ey8g}l| zEx&t@p1peaDeT+t@BxDc7r6#hzPP0fWt+BR2eNW=0vWk!_3P)=4QAEPYSgenz08IU z8n$ZNu6>7&op=?~7d9H)Wwx1?mI>q34+e8kfKc5AO%4ekmJ%{yTxVzJ<~C^1uwf%c zzv*UXCS&uwyt;Mk*Kgj!%^p&@oD-!VtYx9M=G+E6An(0+&lSiB27;Lxi2JiLva+*r z^$+Fb)Tt8+<>uDOt(%vZSFawdHKJj8wI=03^{k*7Fw--ffRmY?5zNZU$_``&a(G9RlYv?^YTUG0Yq}H`1Z@xq z1Tr9$gXlFSN3@lV;fC9y>?}MgNXIUX76{^QDGNv34; zu!L0>Uc(quy{Y7R&*7b-^;}WYsT;&ivPrkcg}I2klOuJ^U5~rT#-YsvSs7`;>|g+$ znw1&I%*+V{v$E0YN+LT8m4Pu#b7H|?^dul$sp1aq)2mr{=LorAW_tY$6vGGx_!pgt zzp^xJl<7F3Kn~h1HzOOjP`NTE8HAA>CxB7xuvO(Bs-<-J7nc?EUYc!!RcR?X^D<1F zb3sb-L{D8zyFvB96>W>H1S`l5f+`Q625uWI(@_aY?lWWKoR?{9Us}p8ujlZVGLMCr zLt+-*3owTK8ONOS;=I{vtansfjg&0^odmgN=0c+#R$ea|FWig$XH+gRn3OpVT;nC4 zRLS07_S3q1N$IDf4x=}3mq@Kinx3Df(zE~T?4mdwyEgjb^mc?68CW&jtgE9_e z40smSwOASVAQqDO=Z~>P9QkiAJfG+XF_3l+!yZG6P*Z{dI4ngcN4A;q#Xsgkc0#){Sb!=g@#PzTvB2iv1Wr0;*|Mnxx`?M)-W=?CfXxiXoC-*Ao z-nAINlssg5S=s!>;o^lQ(-)V7jaH>)#dDX;ED0aJXz|R_vc+BJ48+sz$;8rm^N_f( zv`o@f^`}jnhs;XD)8=tIZBgm$vS}p?N(*|o_sI0lVQ+Uvhcm(`E0-DJ0iF&rbya3S z)Xk@4ae(-6k zQ?h7Lc=p2iOBRGrEnPe(+#_5xW|3;BaFxYt%G2k~%kLaU({&CnnqAg;ep$()&hw@( z8$EggYJjDRT9^VzOE&ro>Q|SrSmkX8l*QRpVNlS#8ZA!UV zMzokuZ~BZy90!H%4^UnW)g^`PrQzMNs%KI|JJwiU_FiRiQ`(2+O?H}YUUf|k_Nr@8 zjz!g`m09{uSg8|=!yMUE-h%U?+ELoGa+K=ht-Aj2B;8+aKD|^vo;hr5ve;WmR+~#< zN-q1!s36~8c8>dhXOZjaVYsFqjDHWtzX#*rgYoad`1gR_XRQHlEdu{}{9AA^{&fSE zdH-qrTcrsP#=nT055~U-<6n3`U-TOOzY_oU`ESL>efN`*7dKZMffu-%`@I%4#)sY` zj3^#+D96Xm2|O0C2Ok%P%|dgWIR~HRtT*xC-~q`rK7f2^tu|Y#MEfs~SL*$h*^^ne zpL$iwl-F2yzs#l@+DDg3RNIDCWp-E7&Z#ncjH-Q6olLMwe^oCN*7~$2nL=N`*DNzG zIX3nuGshi2`8HH{enI;cBFv2 zR4=clZYjU(ioN@`Q8tu2EY$eOI$5U%W5%GS{X6z(jXP46=MmVRh;s5VTw`!3_Z(|T zPP)C>glVxk6Ukqr{Arw-P4az>JiZ3WyYAe(ue6n)&um4`y#I!^{cC&om0)WWg>o;o zib9Pqv4@7j7pE14+F#_12<4xXJ|a}OI&f4dvM^LQIFvs))V?Sbh8*OJLj1*jlmY8F z|9BhGuEpV^}4z|F-7C6`f2V0<)7KjESA`x-7o;YuPxOm%a zb!cpJBC_W_)Yf{aI+ln1KyuHVE}W0paFIu`u=SqPZ0vI0i*fPzzxM9qlk3KME5eQ8 z$X|Tz!H&pYx_f-TrH<97`-XwXf@H~Zx8B1te0Trq?0M;%++(lYp1llL-aFpAPt|9cE5FY@_S$ogdpyPEuKNG>O?$Wfs~Y;$?bn~( zZF+h{L>ju=w(hpKyB+3kk9D`R-0f0#TQ&dTLx%JVw?AgalCs51!o9lo?3&-D_YyfO zIJ2O4*ZiJc3-E-4fN=Nxg5LSP^Z8mQJd7tfspdY%9i(z&UeyAQmHhIV-mvPK5fLf5 zQLj;cXPGBo*iy;Mje9ln%aC)LqzBD6a0XH4-*Doz(bmr z6)5h6Ov)G+H%*snf^o>a zE_o)CvS@KQ^2#p3PIn{gA#5gj$N2TL?sZYtljb5N!;TG&fTEaG5Xn`Zq+{farsQ1y zZbOE>&6C7eiH)oTbZ+w`k>^a5HElscBzJg{_+bwtr)Mvah3^R2t&vCZa9`TupM-p_ zkpv#uOj{blV9c<8^%Jq%3h7ce{7U~Cc)GOH3Pmz^SOld)UFzX5=P~%iv@<3M$=66h zE07g)g^cqP$$b^lC3n>S8rFZ+I*~ldlRO27IrmQlS-nlj0*#zaa`y8=mTIH|WlKBv zVEEi}eJPUVp5)V%b3 z(kfSZlCV}x$wzM&$#PHfTu<_GPZHZryU*9^Ti?=@gxW0 zFsC(7^A}bKiD~3^>b!K7kc6K|quh;j$=#B_$f->Tr$zf`Mcx?YmSzJEb5>!{IUPO} zlCF_kI)QZjLrAtpp2Std>C_;=_Nc3o>yHHK+)YShjf`ys(q*KOLp9PH7YwIsv5?jp z`8^2IZH17I8ky7uB>yTQ`5Nhqr^TIuyM*-CNNWUTPWPQc4%f&-XicZbCqjxe(yBd3 z&wWBhXe4J8NUtU+VTL_MBc-&{yN8g88X1YJvD4=$AyYKc;wX^9*+QZkc^HG*>AOnE zER8hk0MhSTA#*ii;>mfZ|Gh#MYUFt89R9M9Wf~cUQ`H&pg^)8fav7dPcLv%Stmzt! zEItHe&>=!D(8#+OHBO|DkaCS2F#=@pcp>XFQa%Qx=wu-qH1YmmHAc-w1h7BaLw5lM)Eaxiv&=cDTiD~5F zP9W0;2}x+=ZTisYaYBrv+%}Wk?mZG@`XXgVBeUp3XI!l8XyhpR(BfN_9gXB=fXsYc z*%{-vb0fV($-6=#8W~F;I_qCTVjAgB-!{7r&J$b-HS#Kb=$sBhjIn+@{n~?+4iOU3 zNb6A`C!HW9rjZ!!oP4T~ghrzDp>x*?F~<4r^g0S;-fco68hMRAwCrgiF^zQX05bm{ zLJ}Hj%+^`(n-F8X-_9cHoKg>?0pma;Gw4GXb`cWO$mXsfi-rqHXyiir(8be*7!&+< zexMIsa)ywIMyAq-F1=DnOe43B0Xg+fAqkCqO|tAcA;!^uJCo=`Py45kh(>N8IsGpo zF^y#7I^mqrsE&*SjSNMLIm-)#7!&<=x?(&zD@F;4XoO?kIkQAaOd~JW1zEXL+0n>n z^r5k}UkTz;MobQQ6VRrAL9R{!H1?NR&QwjhV}u8przWJdHHx z>}EnD8mU_k7v~$6A%8o|5 z(T85RUD?q{3;NKDUQu=?`|afS0J-=pWk)0D6@XmgY5tXg{PY z?)$YL$6pZBsRsb^W9jGE3Xq0nd&Dy z=|k6T7h)XmCo39(T=j~wqmh|?K-Pby?401&X-^+|wS%#UGyX(Bnb!s6nifKgX?{{N z9^~4-LJ}I8K;O3EXd$tvU+0TnAlJ=PcBcEuc>2(d=PElh{G>m9==C=!I~uu)cH$2y zJH>vTQ|Uu*cthD?poGPdUKqvm;KuKiof1F!5+{#yQwByHJikVU(jWeHMjjmla{G_U&RoBa&GB|ePJI~%^ZcZ2BFNTuLX0v$IRgjIor8rW zG}4+rblX%RvH5--UJ;$UmI#R~@ROnRly_gM?405!7m)mYv$CU+kI|dXJx?k-3;jC# znu6T>zOu8(Pddk&mo&<>%lq=Slj|9d`(cYvgnK(C3~N zB0tb#;8=7Vbg1+EheDz;e{LVrhwl7CNJ1l5(1*Uz0Dm*=@G8H~8T6qqb`uiQ$e;|6 zmqrSy(8%g8ATJjSiJYb7MjyJ19vc%)8i`Qnm8*mptNl9sX14R{T|%N7nL{7?+D;(} zjZB~qef<+5;Whr;w$g{bu}?@$BbU&JzS#sk!>-WCbe;!q^$-#{+n?Jf^f|ka5)#+Q zu8tsY&lX~wUexwim?j|9TOZ>S-=tK8BA|$SnYYzkY{w*QKrGA|X`p_S~7ZTOToSq;* zX2B~W0?^1iwDVINA>nd=Zqw*P|20TROe14$ke`neQlXJ3edsTXghbZ*bGx5D^w*1p z#5M9Ayp;3XtwM~;d^+MopFp~J&vf~Vd-)Y1$p874$VWZ-+i{rlb~li}z88|v$lgvM zd$aHf8@%4-t_{&?HV$N88zC`23H?GJYM2p06&kt?P6fXpGF4FI3SWMq%XlVO=2Ag% z4IN82YMW~X8CUwXuI>VqX5KC+s-d;xfgJN$K?w~#o(7a|ek3To&Yxi;y3&C8m!O!2 z_HZ-?&BkyVaDN&q9R-wO_7D`g%AeuW@GefKIYv-iLpS#a$}&p@8SDL8OX(Z4%{79e z8v1htP>y-MpoE6@P%C6UC@6fjKf@FH0@X3!5ERqU{q(81<{m*68oG4=P@b8E89MmE zYy260+ZCv;*;Y_oL%WcZQ_mbM$hg+8)rWqyzInW$sD|RKR|E4@K?x1LO3&KRyi8Dd zgFnN9u|SQ?I|Riv^esnJV{?a~3JrZV5vYmzPeGCE{25LR0yQ=F3W{s!;vAr6W)t{0 zc*Kokf2E1pW$0a0Uc((DJZU?O&r**%O;YKS*7P8+kG zpoE70ei%?&vq(_*#)!eiq1y=kdNlUhnJ0vqVeG~TfQR^7;ZA#VS(vEe#t49iexR)m z=H+3c$W0LvH^WnrtJBfk8YYTsXtoX1$$U>j`T0HeVGK*3f32Bz??p1VuD7 zk8Zcn45Bm9MjE=4Znv-5N>EHgx6MPpb8DW+yQ8)Ia`pi$zQKW*_Ff0vjl}TE(a>jy0F5y37Zladm;lg7^EE*+4Q;2}J<|MEP+UV_Ak7(NX0(=iX=nu9?r5{M zpb8B+g+ND{g9I6y{q?er0UBdY5fs+YT)N${<`O{>4c$z)JI*W@6xGn5ML^@t+XTfl z^fKM<1oIg|aSh!;r*^dYp`e6@E*lCo(fm_Tg@#UndvuO58?|9;7+d`HT5kXyYjzhD z*3fr!yOYeL1VuEIuz)6;a|A^-)RHAU&Ri`hrlB&r!YSrPL2(W3#ISXynhyv{XegH# zyyMN+1yyKhJ>BjJ=68aO+x+#)tPgaenc0?A4r}OAy4`6eA1i@J*3e2DC~8IoMKx4T zw>#aODk!F*&*^q&m`er4HPnLctJqvCDB(xqc5g?zINYG;b~n@Q&N816g$hq$9S%cI zKG1CQeL-P*BrJ}gj&!?o%wGjXH8hdIZmC(X9cvrcP%oaVCz)LZRcL7QAfS`Yk%Gc^ z_-!TVcITQi1w}QqCIe`mxl-BE(9?9gW#%=?mWCdo+nsOTt88uc+xi6u&H{6nvZbM+ zbi1dRUnyG}TGt+Ep_z^iuErX=Y822Sv!$T$oqk(C((Nub4;K{G&}($NOUy}v;u^ZK zBhXTFp|Yi+-XnodH7{1Sw)t%x+6icxxk=g5(1monrt4UDz!;#5%%_ws4eh4ez1aMRvZbLymhckucV$aMXV(L|)NFt; z2UmEX-_}3rcFWCtK~W90p9r+p93?2Op=~{ZE;DBds?gA3^?@!oS1DWD{kC|w?_6PS zP_{I572WQY=5}RELz{X4tuy(d63%4};h9u?G-Q6GY~Am-)u$2AdNbHr#=IYi+iit( zakv@s7ru4Qa41}B_7#P4Pay|~p?`9mZ7?Sa+NPmiFzsAt&KI;xLqCoK+Gt)NXpe?= z;{MFJ-n>~*?gMVQ#nxd>fZ}FCP`-w~qz}5md{@vo4RxslbffvRpamMbml@t<=5=91 zlxt|j;Xr>gI}6&Tq1$=#-)s&Sv`a&m@HD=~oFQnBh8)zyxz$`DDEC2sy*|$Z+GMU5 zl&_&4Joz`9e-|`PLw{uhZ82XGv_M0*vdXuaUkEDKP*~SbDJm_kGWM^gTv6Z z89=X?I|aoxG@5SrRr6Cpk%V6>b3D*%rir%4e@CDX%`*hWHS|&@&`0JvL6PVETIbR2{?oimP=$s* zX9+(xUl0`A>DTH^xBH3tnV|3sesmX_!THp*5Tam0Lqpkhfj%=25fpvVuhpMp<8!l6 zknxfq9XA2!3-f3}aSa{W4(Lm>Oi<)yzt$qU-LK5^1yyM1DfaT$=HCRxcKNk_YytF* z`Iw;aD}MCUaG-C^cLXIgv^E{+JM&+HqObb3O5q-zJ!Wn%>95!PD3fFUd$W_ExP~sJ z+x@{DCMfc{Uuy=d{G&NtP=$t89u4%9xm-}}4Zqf?BZ2;9UL`2}rXRh*)8S|HZb1nR zy-c_Ji}|9U=v#iR(Kv8^H9r?*?DnJlV}O1$ZPWp=zlNrB^!{!hDk$={U#r&`pg+vM zf+{rhd2^sY&543y@A$ReguiwEGUp2lzw1Zkbh~@a3j`%JbOU>NpLw&O=zD&xy$yg2 zDEZ*);?uRLqG7&w2sxZkW~(U=(p96r&g}jOHfop zzw+iT&l)EvuA%xz0M)fl7F40384ZEzS?4HQANg(F$PTV=-Jon~XdDK!)4<{v2rzIp z^gVjUX=uHrY-xz!8gLp}KPX%O^xL}90cvdJ^ks%o4L!<+YGSn)6xYy7wnkHHh@c7$ zJw~V2%sNp}_+!7VbDID)w@woj)zFrfK!;dY2#RayQ(hPjweA#Dp`nXL1GTW87Zm=) zZ|j97Kw;|>K~W7gr8jA5;Z5&sLk)GJH#y8|Ca6L~+c059?E9>r20_JBWH(CdL8A zyoMTf1nOlq7Zlgf?lhp@Rv$qX8p5jp@F9~mK~VTBzpYo$aS9}NYHSP?bJ$JQ8QJt!#rs~^2N5@@XThMh#{pr^# z$^tspx=c{`FF$&gZg-M(hoFRp_@Ih2+1eo}y4SB&P6v9N^-n>@K0oRg2AX2+6%^Od z8`PR=HGw!j^Dzb+TpT&SE~9Tf-s&l+LPO~cX-}}m3W}M2t^3gA&WYAZg2I*`eQp9x zv(6Tj(9m9LMXk7?sO{G(quZTsJtW9T^P_h3turhJ$GEC#Xg*P~#j^+Xa{OBD>2_yY z*+@f>r=gP%1uC)H35uorwF+7S&9aIFg#&)Hg6HyV>jXgw4LwaX$66*R8uV+OMjusb zT`tJT@S{CMCs|ts#Wi#+hv>=HbAlq7eyuO)cIR3j3##xVal8AFE)F+M{sxWES9H5& zRs%FJp4-TB^ZEkY&~Uol`BuK53Jr0R&{<%O5)@%8VsS*Pj05)+YnGt6hW63zF0@t& z!k5~8T6fXyF0wWVifU-g7@)=0c0maZ?Z^OHV!bLT9P(#)E4|55>l;Ba4Taesr&_@w z()Sv=m9gY9tCgTg9e;-3)9s#S4HOjDP!Zkk=@!3P4R4a`*D9ymJ;PcoD5{}dbi2!~ zO9dq~bSB;I3Tum?aGpQI7IeF3T2Bj#Y3QS#Kr5{ZK@}Q$l5RI<{UIn)*Pr3nY^YUM zL(~E1kB07`+da!F5MtWQ^X zj&+@&n1dHey7_#&w5Qzq=7%fUL2z5Ti*(bYlvUebS|(mhDv`m^lN>< z(R-oQT2NF&-RO2NvIYrCXy}=CKo?tlwhQ-9jrwbtu`q8fUiXoK~gpoE5oG1|S(%Eb6ae;wk_Fz5hnwAu)Y zX{d~D_j)TLs6s;~qHQN`O%)V5)R&>S-K9tuhpWE#VBziR?E4$7i$o#rDMWD?I)QHY zChJx~6&fmJ;r?blAt>C!H6vPUIB;*a-WL?rPy-I8TdZFN#WnOS-R`Ycy%B7P3JuMq z+udY!6%-EpZM{oZxY-&hD5{~!&4IR9GX=#p)QA0Xo3&Ee($MAYfNr<0QMOw8Z5_&! z{|@V3WlKZH;na4vTDz1j4GpGmz0>+i+0xKwMBA)%I5716VSZaz((T@5wG(uLP_GEkeby#rOG9Z#0&TaR zRJJr^_5ixy`as!g?Y9*?4Cn#tH)TshkJSfy(5jDo;r%uAJzM@EtDB$-4dt;l9=47Y z6mH|UHI32kBUXu^sD>8M?LKP7lr0VYi=+23>snP@%%v^79bR73m*sPl|9 zSx{U81n|G|^1XXD0eLC28 zt;K?j&Ta{%7^l<0zGv~<+Hgb~3Zm4``_>jg5e=Qo0q}wKw4kVl#<1o8VO0o>@ceDrk*qSXUtf5(m zKb=pkvjjynG>6_ zt&Fj(a)pMP!C^RGS*-;bUH$c%L|6H>HAqlcLxnK4{4K>XL`o)?fD5jyec&7Yntris5&=@+{->i*- z5*nIK2m8DAfS?Ku<X=n#a*w&sbD50S(=|Ju5 zMaouRzb%HrPJ8~wP)tKcOQ3%CVr5H1_t6pcw=Y$;2KsGn zW(g0swxh2d0q2nv^Y z3Tiq!4__msg)#QuL?JxLZIoqHpoPa$6ker;vGyCH5RbSDo2ftxdprg27bilEc`h7n zrynP$|6o_)9V*a5OQcJslM0+cbSBz;L?PiRWZ_UOOz;%E?_-AwX<@QGM-+@A*TUgc zpoP^b3YkNpaGZU$D8xO5c~oE>?$H%6do-7QI@Nw&6e>K0jZ~n8Pf`?G(+?eQ{~-#I zA#RagrUETAoZ?nGAXUe8d@}10wL1ggw$M{Ba3~grrziwzVY+>SD8xO50vv|=G4v?5 zmkCOEh`1wi&yaq{3+pobCsBxd3OlI4_NsGyRfYPraGKo)05Rz>w<5nmA+(Iw)HCdepvZ6+ zF|W|Q)LL#&6%-rc*J{Pf?V0vcm7#}3t6vkKmG)Xe;Uj%oQk&b6F11NMn)P-wD6F=h zP-Z-ZbvTsTyq}_Qgb9T;_K%{l%Tsuk3J;+K)AOi{)+nX zG;Gow3Ty2nMIq`b9EwA+P?DmsoUL@3eTFE6$GCMEO9j?povx4$|HD?g!oFP;qMkyG z3arDkDGEE;N>|$Ni-IxMwQv^|XyI2+AvpuTkdEORJ2Z`zj(7?mQGpgZAYBGuQei#o zaIHN^6v{n?dN>R%V`;CmrwB@ThR_Pe66$5XfyhoMHS&0Y4-g2EHrA~Ua0t1duy z+j-O31`9kSTF=qf-D7ta6!(y5T{HyfUVFHpJszT#+!G&kJ#2?iUorD<+=Mj68pqPh5>x8yIkJ?WPN_a@LTCi&p_6LG0 zJS1A@^CIxL{hOfh#KEc<)RGd1X1FEJF+%6F#82C;k%Y6t6Wt5V(5Qhx&)9-H~#Dm=s(H1s;rn|9q|*48)%N9-R4kD+ggcH3P9 zMLoo*FBB{SddD6iDDEMKYoWu4-m{AZ?edVEABPitV4o?d!b1{>Eba|dVP7riR}V=n zu#&fDAKCW^3Lop1P%g)pMSwoBUlz2$L%g3mWGksn>-gfxfhl6%_RlPlq}kfzo*|W#s;f4oz=; zId&0h#inD6WfWXS8eV5>;5D>wmOb@PAhaHD7Ro-Hf9{dt%0RpQT zRGj?Zu^ViJ-QDTmpK75&)*%1%AK>z^e-6^qf7wNmjH%rJmHW9FhocqKf8&1Rj5$pI zo%`X8rPTd{`|UHPbN^57=Vx5V{lBIraxgA)A~h^I zn4Gzu2WjS=C|)$vrdYapFAnBp&gMbTWN8; zkrb;zNWNmX%?K6><9%Kh*vqM?zoM*AaRCcALe(0svL+WQZ z2rLtUAGkXayMbBw6OtFo1geg7b3-0RYaP6)Mx^Yu8TY>{DfxUM9^4w=pI5UGn z_S%Z&xiKE*wv@wdEAwW}G|ajMa+Fw}+aC2aTYU|?_S*ZG=Y}cUn#Hr%?pU68lwo#b z$?Ub;mgk*hnEC2p)AGEN4YNQU+`c^b0knYGLml3;Joj>Da>P+$V%PHA_eigwBZsjS zxnJ{e_i8zeuc+Ib!gbA!a$J69U6aQX%?FhBin=#Ye4Y8aIzH3L{ut$9Wu#Rt)t;=5 z92cNH=?Svgk}QFelE0=A=!2B(Uw~K|Nwk%K5t!g1mP``UlzbTz4XfZ^KC$ZRqc_IVV~ql+BnSR+kgVAi-auD$k`-k^PWA!UaFA_441&UONA`= z6R~?C(xp~8MlRn56u2NRlIMAnXW%fGZvzTk^q`RS8reZ|$?HNk`HAHI1=1z=LyTO$ z4JdHMUXe_Al5gWMmu~|KtZN)#*()@{A6^Zt?=HkR&TVJW8Qd1+y3sc^Uj`m1F{OL*BI26eNo+PZV3q$hG2_hNu zB)fQ$vpq>zf2uts?^-UB<(}juO7c8i>q#~=a``r(z`eJKWZaYF`$|OeAx|>H$mQFB z0^4_qq%qa4`)xSP<=cP)4}2*k-y?Dcv#$HRJYa22AtWEJpTW9DJ<0DNAa(74bmca!;}e4n^{4Ptq}R`8J?HVva~|@+5~)as~cyl{{M*fi5^Va{0_^;K{2* zJmHD+2f}jsHlV=McL}M`2;T-2cy^}{<9N5~)DaUE*bx(hjNEo~M9=?ABqN^WE*$2z z=4t*yolI6erV+jkDDYATAqhXJ$8a*(Y8Z-LpW$S%_50ZMg_AEpC(ZcW1XAJTOSt|q zoUHl|yw~7(4~CNm!$}OE|IdVzw=vcWR2}K&hQS!?zHst|CBATS#}YT3q>#NfzSIpT z$IGD?PEMDjJxjE3^7AEHIQi=mUpQH@#1~HPUg8TU-&>-ElOHcp;pB)FVj{Lwg_Ad} zm&5XZ=1X$C?bNy#vd+aO11)=PVwnmrZ!yylX4q@@EUkMj`4?sj zb$qG{H@jN>-P6gJSjWh5>~s}=vhw1;-0+jtmt!sbWQmoO{6+XV8!2+#XXzy| z8GfEcMCZ?%2ug;Z*LjGQ5|j)-@AptLkW5zsMt}}XY_Y16n2b!n^$=?}NtE8rjkgEpdY>QC8GX zWUMyyqAZkE#j~A6GUiF9Gs@zqj(C#Ec=i~PG)mkO=6jMSd6LO^cBM#$J;^DQWIX$qNS1q&yD7;U)%60fWIWqW z0L5BDUK@$7h!G-kPV?~Fq?o>i~1%lC+!!K`b{%Oe@jUMYD*J;?<)l)7&5 zB$M&%V_|k zn4476R%67 zYQkJ{{RxyXs;ig3242lj$+XH!I(1NW)QcNdFrexgtY_MxtSr`trOe1l7OoJ|neHJ9 z$HOeo465VRE61x>sIva;nrJOn2ak68TFh4?)+Y}Y^wGL{d(`t+pY2iKpK!1}s%ej} zFh(rnZjKc5k5CT&nkEnMzuS^U3%iw;70+EVv!vUy!rs$*_v|vav~0<;F0;#)bX#=V zBEv6XbnV)$YghFbJN!R!?AXyq)AZkI8`ACHX z%IWP^+mvW4f72nfW7B!F;Z1_&p9FtGGg;~7Y_jt7;N4c2dch^qavRe>4L%p#iPihJ z)5>qKRaklYb5*x?L#vY+e9`LIK;)kfwzgU|urq>^vz_rV4FuojUkgtZ^Wb^;`+`c6 z?hEd$Oj7$+?}ow$q^b<4Nu{sI+D8O;K-ElNoNhm1>^&| zudMbmPqpUUPw+(2?GDWS604Eq&h}*fpZ)$mj6*z@;~-}l>hT~ zrnLhf6SDQa8vGY6poO0M#A<}|+Q9(-fASnJ_&!X8O6u^o1^&n%CoSO{~YHSX8!-vv)q?I&O-exXa4`wv)q@zl>c|D@+_|||B3&@ z_BqdPl03(m|NrzH_m!XRV`o^u`n*VWJuvP+uYp*|w0=&j^i%)kID{MI=_SR)?^Gc$oL07E-jK49Wkbq_FPy(*!6J#I zCUn>92Av+=SvBZXsdLYs`%Uj_%qSZ-f04iax=))>&`Y&b&8+8s^m^@w_1+KD+Xr4e^sXI{Z*N+_g7`QZnt3ClK_4O%SLrFmchggf@1~~|-%YQ{Zc6c8`5J~=57wcE;Uuhv;Uuhv z;Uuikm^*i2cdWb#foq_j@Z1A#E~@t&-CflsxOXe)J#DdeI$_AjiJ`Y3Qo9#QPt=sI zw+Q5WsDZ7gvxj8d=?z;cu6Jl9Mq}}QjB(& z+;wr-RLLntSIISGl3GN`yD-(K;2Kci_GF3=15>@+r&>L41k|jTdLF9oOm)7l11r!q zQ2XA}(Wwe<&!qy4#cHo;lB~BP$B`uKt(Z*KTQQlekGf=X>KK*0^%_CCrfyc%b>2332WjP7tyn3qH)CabN;_8TBr4_g@}N&$`II)RE;vCp zDmkT;DmkT)D#T3j$|^Y}6O~*;CVE9t5+$8lA61kpgBS9JH8?{z9IE0y*)rAn6lBzg zKC(*w5LcnGUe{!@Ue{!@URNY5|CW-8N>0f{CD)LN-eAeRQ_e7zNlH7aWPMn$+%>eK zo1P+HZE%fz-1L+xx#=l&a??{P<))|9%1uwHmYd$!7(V8h@Q{LnaIdaCyXJ?x=NI(O z@15T_+-2V4C1oW8FqvGku(TM5(-#)c8Gu>)F1>q(yUY%EnT43H_~b4N7S3N>QoMNn z!Y+#zFPvXCTZ`aOziLi$FEypkBAZfUNlmG*q^8tXQd8b`yDt=7K zq=wMChGBVILe}uQ_7-}Yse&}EZx;bC3U#g z)KzYJU*q(Wh4UBTbEjz~3rcZIh#8gSy`OJRrJzRAz3O0hBTE!z0Vhs4HRIl4%H1U| zL4Ez>z-L9KRN;;(jRdPxPs${(b zQJrd|tIG7A#*(r{rL)UQW`>LBOkY^Fja==NqPgiQWpmS03g@QlrNfYx)$5@5YX~R>#(CduU^Mway2)(zEC*jW;MyGpCR#Xa;ua; zT@zAD;7;Jw+yYgc8w#y*(%YZO)eO^QvOY|c$@(x&ChMi-NUAAd?(X$&jn26+Wk6JS zpGDJhcazd{Dmk_MBCVI71ud-J^SkMKHkI-<<&)YFD*x1zLZ$1SQklQr21qX`sD92t zl2b~lq*Ds1l2gj4l2eMPl2b}3fxVuJ&gkLwYjvYvbxG>=Ld_%SJ;=IB^qg8LNlvMh z8c`{ksN|GPRB{cOq_m8ZPH7pHthWKmt&&r^PTeD<-Z`oEMXRJVS@Khp8kJIvxXx6s z82hFAKvpHEw2qt$Rr(2;s2b=^oJ`g;NhYV1L}j8kaZ);^EmcYMYC>AMm6S|WvWh71 z8O_j{vr86@E5RpGYK}S8y}J{nsZ~|e_*K&7{HvxRE7SExs7%*ef$7~P&ehwpGCegP zC0|oMdP`L1lQLvoyD9DLrYD1>s!fNhNisw$^2JtiJykAg|Geg@A>|eHnxTumI}*&8Y_Yra<;E#MN zrF3nyQTP06&YjA1y@HkLdJQYn^(t1Tr&LBJMpK7`O4dus(yLE-Q+mNo*GpL`ua~ki zT`y&2dP+~Y`KOfLO;0VSI|-fw)crZ?tKFY@(+;EOx*yzCajGbptC*6Zx-M3^mZ81X z?UUY6$z;8qlF52AC6o15N+wsi$4se1l~@^dNX9Y#F^T-#8L`w+;40{qhJqIX>kk0{ zbg$_{xSBqNtLbAnm7Y>_H~;_D*}1^URaE)E^56|2yr1F)fefGfb>XN4qAz*~l zhj2Xo$rR-|{mB!5CM~ZC_;Z}T;(I-GX?28wP}bpREuGKH*;!&aIZG_(W{J(Bj=dN2 z(a|r*w797h@upU+Uek7PtCRQ;3h}1-;N=Orx{h6(O#16K^aZQPv1#g>&agp>3`02M zGhKt<+E7$bm>PL)v6 zS6o6)CfX*GJ~c2sBP@s6w}?(lZN;&-l|=_4r*kEiNiMN$N{LNVNZTekR4J{k$V?ci zt(`5XD^tF5TqROH9(F+16q4s;Wdp9)U-V^6?_t-i>e$U|8lbG(yrnU zW5fmH^0=v*uS^X0fHGR<&0~5gmsu#We=S|vH!zfy7w7#OWYG$r7h0G$?__g|v$7eD z&^aI9<$Q!_L{K_-P`O|ofDtI6b(5@{P#lfX!e zeJs6l$&RpuY@DaKbYLI>z?Y}?YVv^FJcN~RGoJd4h(5x$@$~-E^XU6WKM;89D;wZD7#;E!PmFB&8Ln*! zEnAt$Vm9JzTjd4Uh2%W&)q|UH0+;fwcr#9jH{%3umngZpOp|XueeSUJ{IC+5Wy0v|b1ga-kqs&m7a8{w z&vbpgUGf_+_HT;l+Qab7`0}wgOC^@Gro^UgBr@Iqk^H)a3(qLOh%>w@KeZ-BUdT%< zt17Xqs>EhkNZX7GVKXR%<=phzbm7>~&E%JU%qcXANU0)GVYK`OhUi~+1sl=hPDNx} zy%Mb>xvonrvsPl8wa9B@k<5UlNQo07HuXWoraoZVol;xo%j3j5f5Jwau+b)LwDCEC z9J?Y{e6=!qUPK>Akeh5JKxWD-hc^hy(Tl!^Ng;=_#C8-gh14oae9%kSh$KGdC2WS0 zut_&zlWxK$-C>m{uCJCSGKr6W%i~)spSV6-mQP%tEsxJgzP|JI+tlkn9hbfKLtdUw zj67HDrLgEXg}h+&n?fya<{aYXn6~20=+UXDnT&+ZJR&SB^;4Iyth2;s9#M3nB{HMM zvIqteSw+NUyzeNTfXNP(*mNjd(^BGPwCqrcP0QogqkP**-82zj*^y46flqxVScA^=i zOjGHy-K=B*Ig-T)#|*BR*pwn^K|VfqN>#|v1huJ#PP9e%PHCju_*!Y|NHig#%=B2# z!;u-uBQujn_H zOZha5{eTwl7>lbZ=BrXg!|>4ty`d|kVi%gDUj^_I@z1dQftIz7e2S&!Tqqg2rd_l) z^2V~nk+CaOB12c;>F$`7eXG0tjp2^Lt=x{GyOC9f`uchXj|qR8*5Uv140k~i&Q#VJ z`67RL<{7ySLU}B58-()MNMCg^GX=|bq%v|16sAf`J#l6nUL`3*!(Xdf_3WsHvp%~(6Q8d{zq?b655?QjkKHz=h$n8FLp-G;4WOkXlhERRu16O` znZ3wjh+Xh3hJ*e%-4=+w`z%@zUT|awy-c81glyjo17RuRwF%244QrwqdWx4xD%)bB z$!k-o3uhR?FJ!?&FX9&^mYpcE=|t>na%HqxkQ8lu7FuE&NMj-=k=N!0suy4wD}M>F zzrWJe+u_fGJB2NkC5OL6=nr{)Q0mX`z@snqscBMPMjzf*KO^WZpqW2}W$MdlnfemT z^px1-7)w~qUg#f>_2Qu;E*EgjQO=$PEb`_HGG@o?ElKdwPUHj$}m2pOHp zIAN0(!m>i&OLABvLfD89PKd~6m)a(=Bx1Tl*yIV9%1t<(c}J|3PEKZp+a?PO^(_j2 z>1R3{sOf8B;Y5R1Ewa)LD%M(uo)^kNwDGJdVp-RAB#X`o0-ZsGnH*-YNl7vH9ZN`v^df- zpNmM#n97zhl`Ugx+E8BDQ?K0M{B1aWe&qG&62DAgiDeE;Y??|Urmci!W4#DY=1rZ^ zJ72ZpO|6JG)q=}<{h%hVFY^I8h`t0YR<^XoWqMj%wzS1%OIzGbG}LQ)0B+hz*SSnH z37b|DPJN79ygM^WbbY1#rh&Td8Q#!o|DhtL%Y;pj37ZZRHvPrtQnOs8ucx!p*WEqX zHRLJ_POA)dtnKn|7dpd}cMq%@qG!eTQ2lo7u7SaD^1P~Z9o-?LxHVIy(%;cJ#rgZjpBAcHKzEjLm7c!k7rDyvH3OC9eLZVd z_o||lvzF8}SMe7LRnSaV8T4%kZ8>Sd!g=9v`QDlD!=VaI_l1h@xN<>ide9i?>gZHy zpzf{dT{GC#IoWmhcC7Zj_4x>)MLLSN3$12ODf3cfGj%`wfsUarf3qS=&LsLVnSM;A zAHKW2UF&@6i&64#Gw@sS)88&*Rj<#u-&%kw^EW|S(~ofoV>3B4N`2>})oSX}+M(jj zp_v49uzOWcS8rb^QjC+YR(2C_lUn_rp#o-^SKdjHSKi^<1;|^87dP}D;W5T<5-@Xg zZX(9`+oUgv@-c2G%E!8!qkJ28Z z#%*HyJG)I$zKg4E8;c+3)<^lSZo<4+{CJl~`EIVKf40+)F>ZIaG0OLF<1g>f;eHE@ zJ>9-hzL(3Qd~Y`~%J*@vUJ=vxJFM`2;lpYlF{X!{|o*IxZjB>JYECetoXjZBSrjkicbZ9Rq@5(<4?+iuHVl%JT3%p zSNuxw#fskwej)g_(D^oazv54VuT}i7;Fl>r&hJB0^y?aMKhohb5&UMw=YVfe{Cw~R zIM3j9;7!GE1a~Lrp+1h^2%ahaWAI$@=fJCqkM&!{6#c4!ucL0cL%`j9sy74A!87nZ z!7l*M!H)yKg7v}u4$I+D2VW1qBlvg0>)_{u{|ekK$OD-O{!j3BaGtjZjHP~6!HacR zJdOij567x)J7V*MA7%fTDqS)k5c2i{ct6X5QYJVbK*2Jjr5jym@Z@S5V^18*q) z80)`-6nLIL2fnT1#Wv@~`0lLup4$-LUGXEp_fB6s^XV{ z->vwK;NMpK4)BKJ-vfVG@n3-dSnK_80 zD?SsvruZW8hT>hUf11?4jP(`&DC;X;>}grFv!VERS%0zA-^}`ozrgy6Z?hBh6+aN% zoi6pKfai*z0$x+RgY^|($NFbT{SULg;$L8W#qVQ%#UE$=Go}9Xtgra!ohc7B#rFem zC_V|?Es^>Qz;nf`tgraHSzqxFvHn?7{|l_I`2DP}_>-)!_zSFmw$$Ht7s^Af_?y6M zicbY^D83Nfog?)-SzqzXSYPoQSzqxxSpQt9|9#e1{3+H~{6*GReCKhL2X`Ln-|gse z2zW#Bnc%ghGJX+w{!Ym|S^s>=FJ*njZ(#j*$@mSde}Uu=uzp4ICs<$c=UKlh<45m` z`OqQxe&BAI#vY}6YH;({P(P{ z`0K2{O2+Rs9{IUY@}t1rMUtNg-cWogc&$gqU(EWeCBKICdnNx2>nnZ_>-Wj{M_IpL z@@HB9V#)u>`ik$l8|9%kAmfh&&j%$x5!?+){!Z|Q;)CF|H8TD>@O-W0pJ)AdOa5)v zSNvzJzfQ*gf%PwueAMpnhf5{j54@rHB=Fk5$oK`|`DK!Ku>N}_zl8M_zk&5Hm+@a> z{VRx99X%cZuPgopxU0$d=fSIr7yChn^ApAQ0ngqmb=tsdiq8XYDtqIpi}Fxa{4nr_;>Uq!ACNj{ zg4Yzk2)wEI`@!?;q|PV7>xzFJ++8o@9|5l_-UM$b{wjF(L8&u-Z^}bW@rmF~#dGld zLsI7)@Ver?;O@gR{%Y{5;NTQ7AU1+OXoEO=A#*TM4}q|V;^P#)@vw}HEl z$oP}MtKcU&dYlj5P<#M9`zYyf{59Y;#cu^~Dt#UBE1DE<_9_6e!; zH}IO`JNge`iaazGKNvj!q|})SURV4yaCeK0?*^|b{vPm#;x~e4pOQLX0k0|kAb3;p zpM&S0mO5L&>xyr`Kjp#QD&sTos^T-i8;UOi&psn{y1;9SzX!aj_{YHWy41N7ysr2| z;O?_B{%P>4;xB?X6yNCp%0u=!sdFfJP4TyZHx)kSg`Y!865Ig6E1~0bW)7 zCh(f#cYxOwe-ON(_|L(cif;jTUzF|N?oF5viXQ}?D?Saps`x_in&QjA>xy3j-cWo! zcvJB&g1Zf}{r7`sia!CKEB;6Ds^Vh~qCC_T-ygiL_$2U#;`70qidVqhmt_0bf@g|< z5Ik4>cJQj=_kq_Ge;mB7`19Zm#YexH^3YU#e{lC@+5XAknc}B_=ZY@_uPS~icunye z!0U={0BQ`7_ z@wKe4_y<{E@!MGcYf}F^tgrZEtgrYVSYPosSbw9`-}?~cNAaV<>x$0>Zz}#y@a*eS ze}MHBzn1kCud}}5-(>x}r2eCCdWSzqxtSYPpd{K5(6+lse=XZJ|`dEiyW-vwS* zd=2X>{z2CNrqsWk^%cL5^%Z}D^%egU>)$K&w>b>+U-37AuLs}L(PJw3M#bL&zDeu?yf@cp(z7D*h_$*kc@u;ys7xMM^YYY z56k$2z_TAnJ{`QF_#*J?BQm}l-2G7U_khQ@TTGqf!BT{`BQl1#c++QSj=2%J@6L-Db(Z z4_;UNDe(N~GX5p-rsCt;F#mrc;|~YVekpkl-cbBJ@aj`CegND(E%|leb;WN3&!3U; z_klOT{pnnI{0DgUD~f0S2k@%mZ-Cbo-|HC4LsRi1!Lz2+pABAB{2cJQ;;UI-@he&X z*HZr$)>r&4)>r(8tgm>J^?xJvUtxX4$F)-)>WUu*-cN zir>uozm@u5V|~RRW_`tOD}Fia zEB-OoSNsmv|Gm`z9_uUq3)WZsudJ{5j*}@5*>h6=5b&zv$AZ@tKLfm}_=T+h2dV!) z)>r(KtgrZ8tgraLv;Kce{ok;@;{RZM#dn_qe^C4g@a%c1KL@<3_)_pXc-_&XA3Xmf z=`g<+)xXR5<>2lgl3xm5SNsO>{C{Np2Joih4}jNRlkrc2XaAJ^Pv8y3$4;j_ zR9~0z2Y|abB%cgkS9}3@?q<8{%-KvC>j4@@NBf?Uj%O`{s4G&jEw(J za5q-+KZDm5-);uwA>T&EzZtx#_zdvcwle-S@N7HDSAaJZzXH6vy^Q}jxZ6SUuYuPU z{{eWuqm2I*cvJCLz-v2E{8Eh9E;A_)O~nrd&v%ybv%u?$p9b!Bk?~#NRmJ}WyrK9F z;Mq8-^F{EQ;`f6$6@LOe-&N}T5xlPWm|2tuH(ti?4_;N=|4n$f?%Gg%K6tj9)Tw~i z6kiM8RQ!YB`R-EZHt@RQ-vM`f$oR*=tBU^tyrH-|mim?LDRuS%uPNRJ-c)=Zc)pj^ zIUl^P_#n93TgHC?ysG$T!5fO-3!d#Gb$$w7Q~X)*rsDqu&-ax&d%lhGQ&;>baJQd~ zp9@}9{Cx0+;zQus{!-_9@S5Vcfj1TZH}L!bsq;8^UGYDHy8~tX*yE_bRmBekZzw($ zJbRPWSqNTJyc4{s_+{YvK~m>N@H+Se_}G_ONAU)D_GZ%I_$R@uivN-I6(4;(<)Nwg zzTjCV_1nO!iq8eFEB;Q_SA2l=50?7ZvcBSV)>r(StgrZ^tbd5q{~hZq{u=8mzQ+m3 zkK#vwXNOAt+2B>h&jqh5-pBfiU(Naxr2eN_U-7$HU-2KYzT&@O{lldG-&tSr@o$Ge zD1JD2Q}GkPv$sh7v%ss0_prX=?`M6*Kgs%sOZ~62zT!V*eZ_yx`ilRZ^(RXG-E#Pb z;%^17D?S^%srY%|*;}Rl#jLORwXCoBXIWqIZ?XOnQvYYHuXyoxwfMZXuJ|ZlJbVtT zcwz4a&yJM(lfbLsnWM+a;5EhH1zuNt5WJ!Iwct&~KLhTL^1t{;7XJ5t=MJ7J{v+^Q z@n3^i6@L}HrueRNkT=EO0^U&kc<`p;OTgXHz9Rp~!vD@)1fD7WKJZ-ePk>hy-w0k) z{0HE5#h(FhDE<<7Q}LZoq&&Db+5SVpGsTYu&lNu%ysG$0@S5URfY%kj3A~~Bo#0Ky zzYp$?k?sE_c&7MY!E?oTm`i!6DxQJY6rTZJS9}q8L-B6#rs9`_yLQ?Bo4_;0zY3l! z{xEn|@n^tmioXnASA5(&%0ol(w}3YlKLOko2I3!C_}{s+!865s!E?p02Cpi9D|k)u zd%)|8KMLLepNRJS4%|(qb~1krJXd^=lPC{0#g71QC_Wq9O_BQNg6E3&vA*J0v%ccD zvi?-5e-G;`{wV7!{w(V&{yOVVllps~OnJx^Zv(F>eiC>?@e9D+bg93V^%egR>nr{R z)>r&~)}JBupJaW-UtoR3x1EpqulPaWZl=_q4xTH%2)w3vH|r~YIqT1o`Zuw@;$LNb z#UEyU#h+pQW2OGftgraE1(^Se9}eD7JO_7glltd@=ZX)ozT(%hzT&sB{&7ny> zzee%b!Rz3Qp>xnXsJ~ml_XIx{JbOE}bLA*HuoS$W6JLt>wcu_x@do%!;0AEu{A6Cz8%y;75R0!E^9a!0X`S!Mnj5D*kG4H<$D| z{&V0NxL-cu@gR6V`0n7(fY(+0>)=~d{Qjp>zp{B$??mXl4SYWMj^O8lS5^Ea;Mb`5 zo51Vf?W0KOo8Zlps9xW^@OT_NFWw0F2gknzUYjrDcV9&9Z-R6D6!7d68NV332G05H z2j2wF`Me(7y@Pb}QK4Dx4)A;-ah~UofY-rm6z-k_&rYTI41DZqm{;ID?i0WlgO5dg z4qgSn8@vjhEh7D+!7t-@@aw@p1@2Cxc%J|Fg6H6zpUvRw!8t!Kf;UwBo<1SP`@Zpu zNuT4}!E^9-v}ZARKlskzJ>WI)9Q=Cl2KadJ4d6``{|I&^gp6}%lf*Mrx=c^!QLd=vP1#5cg3;JbtW z0{m5Q_S=`hv$Lr^?33e{P=EWuS?37wIyld_x!~>`(qVtN0K6TXb=H9|2IuyF1iT8q zC)$6f=Of#jgZktoW_q7lLn#c77YYU-2iw*DC&3@XHi0@8=25>!rM(r{d-PJQXkR=Lvog z+F9PuQ}ObCp6AUDksM#%&r|X8ex8b#_w!V|yq_odI<%*}pXXAlHv=#4=Lyd9t-PNn zxc}H9Jj(ldg7dsB@8=25>#Mw=f4LZm97w%%7 zuLtM$m-q7o=hwUPexBeNbjtgADqh~t^L&}N@_wG+IdsbVc`9Ds&r|V-wzjU9QN3ne zgL8hGzWyQ)kARzXt@ys9u&xy^*R|s1x?WE0G3#3Ka$PHaE9$)v+^lQG%XO`Ixvmv2 z*EP6V*NT_xTJdsSgY!Bq*R|s1y6&X>aD2J06))Gd;^n$lyj<7dW?gqty&2|Vxvs%^ zU6kt@+^lPGv#!C-x&}Avx|`Z#)-^cK+j3oln{^G&?Jw6gxLMcWoQHB)yPW>V>>}KJdMw_i2ymyyD}X+r!-NefzTt zeS2T`-8?Vi^?l(9UjV;9ogMVYxs7x4pw2|)5(BJ+Xnzu6#&O?=}@J8YtK|it|#PWfm!J#$X-EGVLwjrmS zct&O6f-{#?Dz39@plijd!J)2!%Fyb{a=$5Xm*2jn(%Dy8(bKoAqo>m8x3C?obgWtD zmiMjh@97%q>TH`aZC0@rNhGM!y{dOrrDI^A;}XAD%Fw_iu6w}mic;xZvwHOpb-9oBhIljy#T*t1dXuS0t_CXe~8ypqR?{m5w_ z$a$SBx&{|_4b15++7~wYNgQeE=`t-f)q2_iDBg;#9ZR*|mrJxnD2g@~M@l_?q@`B0 zehzKmGpMs+kBwALW@MPAXrs~;t+dBbUpae*skX)~adhOeXss!`uxCJ|Asvv?FBMW% z6jR?14(&Q+^l_AiE^&0^sz(r~wzZOO^veKWh1fv+(yoEN)^_4*-|!;R@4H7^jfcqc z8AX;)^`>ma2EJyCt;kl;euuDW(b&jVeLgn6P3t6VT(25I+m)JDOo~?+-&;7c$DMD+ zr1of=WBZvG(W%WXqau^zRmL{p_1bZ1+Dp*%d~&?mvAv^I$mMuh|vg($WSsTi{lz(P9{3F6?MGI*f!w4 zGhs~_X)-5+X>cu$i;y{)Xj(r8(*!h_%*kLfCxgkH3{LDAOmosiC-$qPm1Cl#+l3ah zB#|sKCnH1VWH6bN!7wMw6Ul`+nRu9!<%x`uIhk-WCxa&?1`pSsbsA%*jLtV=**1g`s3l7RNQn zoJ=&Clg05W$(&4d@D)SJoD8P*W^r7E%*jO4`Z1Wy$zYn_29r4%Oy*=TEj5G5oDAk& zbJck?tsD~#bFw^O*MnUjeobFw&IC7F|n4!&Y2nUle^-YkxbkU5!XT0aJp zIT=jmWH6bN!DLPb(^4~-%*kLfCxdC_7z}f=JdrFiClgNQWH6bN!7wMw6Ul`+nRu9! z<%x`uIhk-WCxc;5hQpjJPox;;Wa42?mXkRd4s$Xb=43d`$?#xKv!do?XfP*3gE<)* z%*jwPCyRqQSsbr07>fxGPGKmSlf`ijGA9#F=45faN-`%C9el-5GADy+y;&R=A#*a( zw0;aGb26CB$zU=kgUOr>rln>unUld}P6pG;F&O4#c_LY4P9~hp$zU=kgJDjVCz1QJ^ z76*T_I2e@0XnGlWAE_u4OqbLd(gwEGOf#oR*d4u&&5~ROZOMYyomF%gMeh zhkr#5q;d@hvn60*kprppk%`#?FR7!6M{Y?VZ+f_0mgUMG6hM!rUkb$3>c=(y+ ziF)B@CZ2rAVECEgSe2G1bl_(u9&5~S_?hAGGsEF$hQrSc$AUB*er7oQ%y6tO!`aX5 zfmG(;XQlxB%y9Ub;p}JjKq}YlXQl-EnLUt7AN-A+t2mCik&8-auOZCK@Jbd1_uIMj0#I>Lk(#*Rk<4 z;)4|Z%4IPz+T-1Yc^Uo5iP46w*m&|f!{JYsCnf^i$;1b9lHalNy$Xxh&@ej;4NKS1 zkVQj-IT;!P4d!GhnUlrAoGgxakIczN$2&;oWTWFknUjr@%Xcz0-JnrJd7gUOr>CUdel zG1uZPfjJo!n3Ls+QHD9$crqu;6Dfc>*?2N1!(mRAr{-5;v|&zGhs?=vn3Ls+i2!pl z@nNRQuQ9MW85$;}p~0LC4Wn&nFegL9gfTRjlc8iz76)^(INm)nCmS8_Aeobmj(3sF z$wbq%wK(2Dnmjf-UL~26i6(QhI9?^0lZmG3YH>VOWKJfU=A^~(?$F9K(PT~rlQ|ho z=45eVuEkpdb22J0C(9F~40E#aWKNbRQUG(Z@nlYh!<;Nn&9B60!{J&9Hykj!JjM+BW`hUD2v0iu{d~?#bi0?|J@79p1Otm4NDVzKEK-6zEOH=~4Y*jO1lgE903VASNY1>}6o8dQ zq{z$c0hn3jKx%rx&U}esH;-97(6@Zfnr^;x4&AUMb$l{D6iXeS8H{JjR`jR3Wxb30 z2Iurf>YlolveQN=J8dgvr;ku}`c}%$7@_QpWLe5ryeuC}<&sYZ)47_tm3n7J+f4PQ z%Tm3wqGkD5s?DSwFU!YLWy=?pbcaWnxuos`Vx`N2Td6zVa5QYzRC&`j z5~a(7(UynXMbU~iRS!Eha@ojgEXyWVW4H@dQE#FwK7C8oOT!T_%g0h>`Eqf(zX=y8 z+Z=I_VaGN~QRXQ|#gwoWuMCtNiPtU+){|~QSvpYM7-E~eJnp3>U@$0Hf6)SEC zmnvqCwQ4KwP?suZj-gn{V4_&;*sx-$Muwa#$yPDbeol!m=8yFk=Ku?OPZZ|?;jVJ2 zBU6)QrX`O|Pac_(JTfzRWLENspEs#ydvlK*3U3~wSqMj>eGNyVeGNyVeGNyVJqkyB zyO)O%sI2HJ?y5Pt(y?}(zw4jBajD>wTD(#@>5SQ@&a2E@G}qtJlx}azzl)oUcDl;k z^A^oMb-{@~YS@vm`aL>%(OH#w^Px6>?isFf^1{>R%wAYI?WB{=oVTR1WcHke^NJdJ zRxMjzSw6TX-0swMEbAK>%JY*KE|_y-Wpdl(wrQ@iV9BYK*1c7ioO)t$XVoPg%X+$8 z|C*se72Va@G1TF@{q0u=yVRkIZ`|^WD$7@1RO#+m)zdm!+<`T;BecF!+&r~)Ftnjk zs21f1hFo|5z^dM%ZXK~=bzd(9{M}+Jv(G-)5122qY;X|O7p-&4`+dR&x-PDqJpWSH-Phlx z8+^*z${DyD?TI}dgM`AuSu5Iv=)k7W2 z{Li5Q`ni&S^C|2a=yz?seM4Psv*#>0dZ=Rso~`Iz)3$8Qs-DiHS9Q9!;@QfM!IiG9 z^O9b#M?Z%K=*Zfxfx%UMz2Zs59~W&>q?m(ke#~5(zt!(* zfBRm~x|Xe3;mdXO`WxNy(^b9Qef)dJvSkBZYx!Bvs@^XC-RF$&hW!8k^8jD8xHU81 zmwV>u+&^<}CcuH=S?fRC#<>K=ZIQS0|G4~;(Yb%-+!BB+JZt^O_oZes$^SCE{Ltt; z92!D--p3$7|DP^D*Rz-3c%zT&zj<`-iE}ptaQn9j)H%N2G@iOe{+FHnKQ4do=-fYZ z?p}Zl9WM4AD1PPgxc#;Bw}W6an_QgZjuls+ck10au z6v6({K=}sBZz1f8_7_^Z{D(X%a#FOfcx>Dz$ItM?-zi)^AX~y~{cpp|Z$kM^NZ7_Q zl78WR3i#)Zs(fwRJOtLzAZ{;}ZndAEf7<^ty#DnlzaHg3aso%vPp+5g=T-R$^YUu zV~d)&{tV@_|6}=Qec58Dx%@J`-fSFfOg9Ph)zgP-%y zKYKd7{pJ1(H7dUn<@g7ehk>jb^lAD#r?10zW(b_ej*3rXQrNy z@y#q++O9a4pQbqVipms+c1C#>=I%uO>(v1+&-j2u`QzV9k+)pJk@QoSKRi)>^FJu^ zRbH5o(dDNl%5VB7MLwkrK$oA5@;ZNaY)2J8>-RAj{^0Wbb2opG$8LDs-}WQAkOOg0 tJq=^0x)>sFt`KcsP6ZG3KgM|T;CaWdD@FHW^*{0;l|M4keo}Sre*y9r?`xBmdy||tJyt}HpduD29m%FLNhrxI=yq;8 zFqb;ZYZq!6MwjT@Dqn0p9;=ws%2$ieT=r!Cxko$gS@!u2+uwLab?93{MOQvsHkvpd ziY8Uc>wC>_l{4NQ1`aKqz2Zxyu&bxRzB>jNhCI6IO7yd#N4GqBjz>@N=p9&(ri{s+ zXnQ*0KxE7F=r|DB@;!Qni10enqi1^ba5%aqP{SEr%g9@lxFc}nU0`_&-cR4*_PNrw z6`(8i+Q83JHEr0#_EdyNlUHD?*BINl3`h4;yEe9Q`bQJgu7Yix_R;m!E`x2H?$J24 zGqLRiP$(q9L;W!K^~+c+|FI9Q&YQmSSz!`S4&N)69zHVaoIIdkga6dGk-s3P-cj>b0icrD_^u zcewr|T|2@6jXO&Z2hT^QL*TJH1NA{tf0C!Ip>eNIO1nd;>d`;a%hf+p527sSy<9Dr zyS&xBAKZZ~8-8(eUh8u88Ull3_Rl}jHnrMRO7zNwi7o2z_mwL<++7=XclL@#YE>`& z5h!GQB=*mhD@TU>6Mdyt4QD_0Te`~y&jQF>(L1pv*qhWN3sG3Q$N(>S3pV46ac8Nm zC4nBvKqqGrEOYtNZSRzW(QLspVQY2lG6k)RX~iPi3TYlvrx>>?!ug0B>&C@&3DTfW zTNl|Tke<|sRkMg*M7q~QqaW8Ukyfb>sIUDUJy^S9S{>Yf@NZa~Dp$E<+tLuEq9tmB z#=91!!;9TL*I2N5|0P_M5};j#z15%{8{w*|NL|-GI-yRv7Ml<@S+)pGmhRj-3;eq4 zz8-|4h1zvwJ~WSvxfIQ9Rxzy*$Ft{BbbFoLwDq{Z_)>I3ql#%qaDVEh=(dIx(?We= zzyGCZpSsgajfDN8!9Mm^^wWA3qX+7iD;4qTll~&RO=x%LU(s-jifN~De}vmVzn-uE ziHp$*5HpkqeXd-LuB=xvZ7S~nbdkmq$Ne1_Ay$J@`(eK*{#ev1Myu4XsK*aoERNsm zVsZR(ZvXsxS<%Pq2X&k0E) z`XKk5i9XPzg&w%@Oz|L}I#WEzg=eC{rUUf8fBjKB$gDHPgFNv^^y#KN$anvUe$~`B z$iaU^OTo#x1_w6jk7%=IP14rke#<{zAKz@DZ;;bZMb9+P)dSZ!RXoU?Q^kWUb1FKo z#Sp#k{FB9ljGinWeH8r;7mxVb!^I=+ zdN?|?{WW^ub%%;a{LZ1`5kGn;dbT|;>$F4B`W<}BY8;A&J5)^j2M1Q>P;_30CTS)5 z!+!F&*VlKLZt5p!>tCYHI{Qx0b3YdkGVPb*K_2}%`dsIHeUPJnE*|7fKNk;j(9h8x zU3ieyeufxTqxW~o)>rejpNd!W{hy+{p?@PB=mS5!e!0tW-$1WF82zieZ#AnNEFNgn zgT(_ac`$m9?OV;+KNJsi*$>47z4?b|om?Jh=O3cObA7A%`S-jK9NdM@u+*SI*?)@%W*rSKOSk8CF<6Ze(@py0lE?T{(FFpNupm@B0 z94H>|7YCx7d-8anJPLDs2a3nr??AL~uO{Q^EwkbQ?JaEew^yzd<}K@ucPS}y zml6f>qaB60BXY0FU3w*Vcgq@`%P61(%W``_jkNqd}h<-D|kyb z`R&VBhQaITcP?Lf30{AH_wtq9@H*_r%U6!W>-+H9CiZfHs$-_V9otu+nwyn2#mrk( z{n~56v=HxLa!Y0}HhY#xwU()1TDnmUq{;BF!n?6)x2h_s7$$r$cJHmKM+UlHa`5sM zGdkf!Ul?SE|Nrm*Sc9Yr#e7=7rSSka#T2G zI_io!ZbI~PRX$cJqFy!&73^0i(-eA|##lH$u5E>kSk3vWhBFG36!Ma;zA9lD!F&3{ zNzuzN@RlDpI?}WU4${*q_khfwiDPaD1^t&pSLrE@x&asrz{+U@AZ0X+(Q4Tl zcQ3_G%~zG3byvgZ%8U`9_(!T9tpsOh+Gs;%;f}R3;-r6;ZbMJQz-7QK?FK`YL}P2^ zKl2PD<5}2k2%R&pgPm4J27bWnAnkM`t5q3@JPkigXIOSK+b|sH5I_s+I#Id?jI06J z^`@EBwE(+f&mq`Mz}|A{2~G#WQl}I=Nj;ZH&pFV{YTFjbZSN9Ut&y$mfZXwwg7_KM zIt{(h9ng$ZWVFdkGB9uoeA=YhRW`B~!FiK1yD}&l)?Vp(76T{X3`@DYHIdUAX;lZv z+<`>0o7*^lm=_w6`-$QnR$vXT!2FriwQ+OX?KuRRSr0+VNm;OxNRCD(B3bkzk#-tM zf_=*WJ|NPih&b3z06G9WG_Mjy*41#Xq}+Roy5>pOkD-}W9m(>w#=QtF9*$*GP*BKvvHulF&$x`am9ggh)~& z^^rXBCK02B4U@!k4VqamHURSEXRzyJSRpT>)9_aSGTH%kpzGSdK!Gz>dVYybJhw~2 z^+Y|>jI6KfLeF(|K*_KY((|(P>>xc;;M8sbJzp4zJsm44T^nNi18_P~y24_8Q4_kp zJQI;+p&3>soB%oRZSD zf{~Sl`Qy!V)HN(U_e#&q0M9X|P+r%KPKq$gZO8#+PH#762l zReC;v&E4?B!5?%4YZ`(15G1Q-Pw2nn5cQ8p|M#Go)w~9f5Af|j!-{L4Vo>@d9UP8+f1)bcR z^b_me3CqU>qcn=CR{+`fo&FJN;fiyW!WS>Ts zLgo!L&4%yGGOYa?xf;HK2{da=ta2LZ-x)~z=0vJ!Bx4|u4teRY{*Zw*v>8tAK*xz>R9_>N8Ug7v zhe%V6m>q$1UPYvpM#iE|m-R$CXk-9fu>q&+$Ar3RDB2uQw_l0$(#W0Ffpou2q`yYK zgYzR`SIWQ%@T)!{8J&?`b@szwIE zkqq=+Lu9%}&ca~}^m&8G9bV#OH7fzA?;b*Tc~MryAdtKxL?Rj)gQTCCiE~}7k+mcf5$w={Eo{73Gd=nrVZFhWLKZ=fldPA5)x18HOs zrqfAF+&~&B4JU43@>6agjXaIn;=1>cIF`}Q8>s1EKvTYU18JlSX1VK6yMZ+F1*X%f znQ$FtSP6}EZV2Rtxz3Ce%AhUR0S8%L5+L?aV0o!)et8%QHH2Licy zxf`g1H_(@uO{cFVVr!&DBOuN#2|^JKRmKG>I6x$!kvq`n*0XM)j^03%FrD6363!Jk z7c}w$X4Bgn5{YPJd3DTxcl02X(9ju7r+1DaVs!Eb>W%4i#tb61Mph02GP96KL?d4# zne_sZgqJv3ZH57w{XQY1vp3K@BzGMoVrwJ_`9E;?MIsT6^oErQ%qdff&IOG$hchQI zwkFsxy2QL!?~c5n=qUH zFNa73hyz37A*{f3x}-m$gl5#f4Unaii5T6zf!@GC_s(+zX(XpAkY%ggKpLru*>w49 zZX8ELEis+0*zE?gy@8fuI=%0Z8%QHtF`eFTl*YM6yo9o8RnXl$Nx0f`;bo%fiH&7ohncfV@8Us#M$bTB?F&M}rRft6TdToYQ z0`h2^GI0Fi6v^|V-`fIuY!De4{k&udrqjo#x`8xO?p{_ll2 zk%X5xSz|DrzW5HI$WX7*xShZjWe1Eosaz6UbZp-9Q@2H-KzB;|3bzwONVh&!%8`Iv2)z z$t)Ad+x3YU<0Svl5Wa`x5_rcZlmLXAJGe%$(1CYH6N!xXl7+Q_ymyBiDC{NA4h6FL zJ~z+=FPV!sr(4#!aU2a5R0gzlyBlbt*C-FyC-J=-Xp)z-$8@^wyc=k;m-K55WP3K` zM>rQW@?=XOI~oIl@1G)gX29mo^&3p5@Ao1jdy0opIvo!>CDH)>gs*+BFA4p3-9i10 z>$!hFXlA{S+4RHvh=etA6tn3^>yS8BLPMu8oqoKXj6zer?moeE`pNf1A{u!R)9LQ> zM3NergW2@cY~YX+Zt!~Rj@fii1m4A5u2$jF%HH5xe>$lh^8!Wzj%o6lzv zNoYj11G4V{BB2|--fn0J#QEYSLJfZ5Q%7H zC1%s_R}o2iiIcUzIiMfb6S8mdx_bxH>A{bQ#5EGabo%43M2rHj&Fy(Wl9!2uHS$Cq zAU{=tD-5oNBI3YVla+!e-OsHEg>Ln_+ut6@F9V1~G_qkBkYA?|Nou4^I*{KYMC{wV z-tH^`*$aEl6G z?%d(^)&sNYv1&vjK;Za;Ktq^{d&k=mN@_;W;|X*kpNM^@*Igl|)05MP#5M9KX46v( zi5N4yHg;JcrynO0b~N-Trqe$*5lU!e^H3mX_7Mrq^t!vD4Uj*N6NzZ#00ugn3Yjy* zN@^sG+4NipenS4UXL;RSjp_7!Co+m_WI}5o7lsirW_xYkZVBY#bRuDmoPyIU@YfO| z2``~+`gB!Te@djO^bj}u91B#;l} zN@_J+0sC%`x8P5hO$}AcAr{xzi;zPCN_8P*%<-B<@p>@T2tr{EU6TRGQnwLGXlP9{ zKq+bkq0n5fLudM6U;(v`SVUvn;M@B^s@g#)si8{k0HvvegzR}n zrqv8p4)O|QLI+x+&ui5HzLU9eP>k6o}I!?&A$7^*8 z^J^KERs$y;))07t{8LudCYI1xdrYzAR98Zw1zwN$;>^mck%S@|`T~<|1$8^2q=u?u zlC7xjBV;dRhYl_NDLkzzsppBsg%SF27@*4PeL}_}?>L5GqOGESBox-r3e2=s6@IY^ z*FI(a-ypI%*%GgoZM4h;`KoLZPKzha)f*)>G*r zoOHy493%KfZD93P9b!ojGlE}X)@`7=5wh>~dYq4Gx1kzED6XM17_5=HgOIVzYc&fl zwLoKaKcO%n$AHbf0`b3H15MNm#1fj>Y)rjP)dz$^%Wbd`tIsj_HdDzE%}hgSn8%u{ zzX>J1h_Y{mT5vDxTnC=gDElfS7%d4FEmcz>kT6%+z(6pd89a^Yx0UKkD6FCKO#!u5 z6A48$R236&8#R|uTtgweWZODwHL--ow&Td#sn-c5HS_{rD(%%CLdJdGA>Nz;sDnC6 zD5RnFn1MU06gbo{F%N>{zYsHUCsmVJ*u#wADsUg@tU3{jXs88d;4W%7p}2-34FPpk z1%whBnsybSZfY5!Bp~Og$BAT)L-X5e0`8Kg4!e^w3cZ3L*d$|ID}&{jO0ebgjENe!j8 z0Mu8_BV-hMCw9bvj2*~R4-*S%Y!GJPe(DWEwuYX>ne|tn5ejSQchCY?DSUy6X{goJ zfCi{QU7DDSApg_ir*;4~P=$ykG_xNu0}oQ22_-djQ#zol)is2SmEM^>TLMtNx|L8! zLx*|*8myKhax7b8p9O&pQO}WCSVJ#kdK;>?6N+eP4rbtC>IXt`4c%4~&~SB;P(nki z4S4?zT%*d?!v#rd?Aw80HbONgWIW)VS;7P~QuQMg(oiiN;wUwlkgcKVWdV&=4xw-n za^PYO?uIioaIIQHEKKLJ9{q8dRctf88i$0n)U2t~YzGVqG} zaQ##6O_vP(JZ9i2>S?lwi^WW622*nYU9YwfN@}P{Q$SPIw}e6u^1#WeWj>%A)LBAd z4Yh+y)(K2gr5ex$p|Njqkifbs;5710C-3_Lp znwWuSDQBr0Y_&Joa?HT9)iZ7|4IRb|e3#nl2Gh{ja5w{Zs{?K@4OPbsJV%{#V?FGN z}A30(g4jRz5 zHHT0b5x)PqhqHPI*tkX5jy+8gNu$W*U0GG@vD_Bcafv-e7O^2DDTSBNW!qy_kXTRksj| zYiK>rKd?;Q>ju-d>VQMMPkrYG)6gQ!!1t^3ZY)NQ zyZFCi1};>k;iQBQ1&@1!1#t0Ks-}d(8rskX&;zP3p}2bTJGw>?)x*JSGsuiG^+T#Y(Q2UC2RxA9*6($z<#G(wG;y~u4 z+?zo^A>$0`3l@*4DgfXYX~g0rI0*iNC)=Z{EujJpwF4e_Oyv_Q)X-kcz>ljN39Z-A z?ivoTC)8qMdo@<4GN8D6lF(@l9qSC}N%bC~>?e6rG{k1506nF?A(W$`x6t9!>I|WL zMoxgt`gH;Jj4A<1I>Rc^%6q63Wrgb2#Z2)yIVLHPiym_P|T(H$nv(!r#yd zI4>)sIZnDzV~ulxy`riTTCbr^AwaLHc7*n7sGI_{UJWL6T0?8_6y2b1B9#5KZQurL z563@v7O&aY)c=U(6f-~-Y5;m&Jw+&ALp6o~dP8j{RG^{WxE^mR{AL*@rlWp<-co-O zTK}{S@!f$yum|x-Z&W2)pxIu{?A@AxHmOF0PHQL&ua~z~FGAVR*dB-Y8Lo8oob8sB*sfP#^XlN|H=WkZ)2^DInRRcg<)F*`2Yp5sQL~d1w2<_F7 zQ>{O+gi>&Gm0_LM*nN0WY*W<;Wk2hk+2eQ)Z&&RJYy9gQUyy$Q~ zpfA+VgyI@bktJZ`fFL*PFDkqm(0A$`LU9eHLBGKF z>MKI_D_*M+@D>pGL7fJK-@j@s7y@=sWx=~Ge13k_YgWDlpdVFzLZS6u)G`}TQsoj# zXz1<6fPPYA2!%Izt@dQX@elm0W)d@A^RnA=!R#0H0HL^sj)nmJs$M2!zwWhassR0_ zJ|vXX&}%T;z#;Vup~xF-<%K$s9E)xsA>GjwJ&yORjGTiE9SP2ca8v^L4YC|ae zme=a427rE7_=gF8&wwQs>saeF59%cl;#*5;-iV})!DK;~LpJ4{R zpk5&q+UiB^pb@yJJ|dLRP>JDy{!+gZ3MXv5{|1Flf(dvIUs6|y8QZ)bYYqbRx2ghj zhmQ*yI$90TKdLPud%M@_n;by@s(eC84Xx}B=(4)89mI#rY=_tEshYs9sKsO!df$sK zmj`5+PZCOK=rm?vWxhu!{DIf%3T9x_{DzRR(}OZT!1L&dRkJ&xq=uGM22{-)O(?XRVnP0=#eWe` z-|8lQ_ncvcUB>88CZHN-A)&a2W()vS(|nOoQbV6s1{5-P5(<6lomf@ODz(g?5II&@ zV@TIqdWPHia2xT@0)Wv+0P+UWkaNu3dy@c$q#0moh zcVY(aW*#G!EMkaeMos^;Lj!%`Suz8d`~2rH46! zP`2H85b7wnVMuW}c#1hDg(7$+Q4>8la7)+S{9;zhq= zuwiCbLU9eXg7YUZ+#J~*;=?if)oa!RGw?O$?PQkJ(1%R{jWF*c6#30-Rk=E#k>>M+ zLWjJl5L4+W^L;`I4RsDVz($)t5(^*pntg?4*P53I8ArV67EH5a%<`Z?641~uh{l>Z zgzTeUtBtU-fpO+lgp!OLckz!XVB^gx#3H|Y&90zX*ql!&bj*uJVg{aIK1wK|q0)T- zO*A(W3Lp1cjY2fZ!~~ULImQVuYlInivWXhZOhY%-0Cb(1o{Pvn>9uNA3(yp^4xyxm z=HVrMz1fXWlUm#?h z@uJ@`1K(tRKqy{};P_JpP6D9Zn?gU+jo>lNz|+n1WMTiw&OU}_FfRwtEoNz0epn?9 zg)jpbm`w>8XT4Up;Mset*_Tk5krN<~-(v>8&74Rqp_$#659oGtE}_slug4C90Nr7( zCKS=ohZ%tGG+!r_)X=*6fM%F`2s!q7ug6+=OlF!#iN!Uvt{tFRW(wTY!bjQ*UaRjg z1J5>V5(;amX)i!`nVkqFG*nmtkaM>=oLK0h*W=#uz~-0*gd!Sp+5(zuE+drGP^dki zdFEO|_FrCyzqG+%<~Bm{Vg$!OxFY~8Vt!A|xa2iEfonD2yg(?dp%`Z1d(1L0L3k(7 z&^P@6EijuA3jOVMc&rtmg=QY1$lo@^hs`|+zO4m&i_A&HlA2jLOp1%md4%kLydK{l z0O)__!-V1*`WrLw67vm0#=l-G{Q5eu)cnjL7S`A(40f;iJE4Sze#CQlnHlJflMY?> zdd$HLyxa^CifCw813)Xx&V-U0a)yL}-Dh4y%)a9FcpNkE{pPKN;u=~!1W=*5oRDF_ zMG2d`ihmKM)Hkug8kr0X=A5Boxt50bD47 zhs?5&QsFa!h8kg-U1c^WWSd@xw<3y}{on<@e~W7@7c=l`b26D3me*_{X5fcShfr8U z{c8bQW3C~T(9o)SfF3d5Bos>VIy_hp-hTs+ntO>wG}gB}p0pEb7-3Z>x?@c5I*Gnj$bn%@!&6BG0dX5i<{ zvu-dA4Z;k(&McKj$6rGqU{ZYEY)mMGZ=0~Wu|`#cy%$XULsB^YVU2ab!}X#WCbPJP z9&7;UCG&1Kn1<3Z3A}8sa)V`fgY|^VIPi+OflydOx#jWrziRGwgK6wAX5jVaVK*H=ryxCp|FN7VFrHP>_8|k$f3nQfXD0&b11Q-FhVIf={L>k zZm=wGu$nfYx6Gw(Fb$mqEwIsihEQBXW@|v3%&mlyj>a--1AE&%Kr9sW2HRQ=&^zWi zLSYSkhl~HNncW}PBd(z`xE}ABO$a456z&3Ovt#xl7AoNlR)86Ji#dT%SVQOW9Nucq zaf4~7FJ|C`8FPba=pe4*HuE(%R>|U6@cr8jAz<6hPu*Z1W(2KlKs(GMZZHi!hH3VF z(}J@cGM|RZ4h8gqS%XlhRBUuCaG8*M4UXC$ofx zCS$Js-Yg)L)X*6?Ab}suWrU1!-qA0?li;AamQYATSHs#nfger$ZSxGv*4TG=x0^J- zCluCDO<0J)Pv!+e5e+THT>Gm2glrA{fv3(9^9@4b@{ZSIRm>7c&CiHM zG_zfO0sU_NPAIOS0Az>2F*9&APCB8X5tuZOn;}9;4Rys-d%|=&6EiA!$MH3qoiwi@ z6w=TcT>Mk!t%Ph1HNy2cZ7wGi*3eAMwSSn;5sG+`6Z~Hmurua%VsS4E;;+L5{xp9e zl+e&P%(Z9Di-eLI>H$*;oHNV9nG7G4Dtadt!Bl(RY)&YI2=kx&8^~3%Vef+3kC?5Q zy@40ZMRPKtu!fpouKmk&2t_n>J?7d=<{CnA4dq~}{o8yqAL7F?(^y~3wf~s-TT77s zG_($;AoCQ~=01H?s~j9TcsuYSy4h_3I^FC#?(dz!-(C#D3p3N|O%@Tc zs0_{ERrpCc%L)@pXs86Hj-YinA)^WpoUGR3+fE5<6(L(go$vxHX>Axn$3LPmBM7XN zwc8D*p-y;^v#rB!u&Ul*bD9GxZJBU7LMqkJ{Y?Osv8oe_Xy{ZIJpN^^4#W}~y9{Sp zpqw?7kWtMW?5=D;<*n&%Fb!311*n3x)D5PgmWV1^&$zJ|IRRQLd@~GGvbMUxs(XXs zUtZ7y z?*w(MBW^GaZNW5K*RqD=q>Yd_*c^Oosb|$7WEUei{=pA%jP! zB{Vb*-*y^Wx46M-d4tWwGp>df^KLK=je>rG=2q!z&|ySFdqaR)SWO*b35`v{YbnR-OUS6> z4VKmwP)lnfAzMSUx&vxu&2@um=xsdXT3f5#SQ>Kv!S~@d*6VJty53-y8v$x-?Qw%? z=p|gLcGgihn1%}B6H=hPl`?`>QA6LA2Gqf-Nyw;&vGDq*#eV`XvyN6LVm2{Bsut{Z zvW63iXlNs5q|R1>8%#q{9AX!1nH#LWXJYh}&9$II28Q_Z*v8=79l@f9^&VL?6pKP= z2HW9nM=$FeLLD?j=T9H&452(PqBtc+a;BHZnFYVaF#W7L0O0%guvlC`2MO@j?LQWA zyshkS4I_*7V$cwq?}EWCV&HyvUD^o#g&_u6i^w1;2BWZv5#q%L^!I;Y@g9b_+IovD z!VP(~?!_jC_*^XHxfj98cts4g4wFGb4Bo{ihA>C*w2KV(V}xN=B>-?SG~x)(aS72{ zEaY#&gB>x%NUI-NB*daRHZjEH{}`Ob5TmTS$ROO9Lkz+uPU0cm0KQ?mW&oal*IF-< zMO-W#Y+{I=|FNix32BV=JsB8HIK+BvVu%Z3Q1mC2qi_;otHfyNVTHutCp5qaPD226 zCs1UOjv*#k-N+&=7Ga;lLcD0RS3V(Qn{?fLCsT)s-xgVo@5KIIxlbF$iG}yVaUb2Inkz{i^22Q#DSguk3o41 zG22QV13j#Ga~{|M=og%g@341UPAy_a3ufpn_!gSYvAPhlbG&9H@&L`VMz|gYkyYo) zfE?>KLdljME1J#<&}lkFzvXqHDy)BCf%UW-rxjbw#3s&X%YQ6-DG0I9`jQL^#b6ya z-vxtHV&LXF_%()05F+qDD=-!pARz|dq5(z-jfLxv232Gc#t=)ac4T3+;W1@m6GIG! z9gjhp5$sqO4DPkACxfsUbjBuzxaU6xuUcTR%vwzbPEssx!ZwC@UAKVaaWDfcR#+dA zh0&JB^cXfV#IOG`I8hD^?z1kDLADs|!6rs1KaMAn;{N?L{BL8GYGAR_Y61k(gjigW z5Pga*t^)^PFbCJ^0c#8yB*h>Hn;2rIZjfpON8vg>XssZFP&=N4GXdKPuvqsWi%)Q& z91upfg7VvTi*42PF0rIAGOK|fF<-E{6EZsT$SGJo9O8@CXhOE2qKtnh=(Gw&pD_3J z0fSepWn>U`4dDB~@z_onhOriQbc^&#VDYN;9`>--ONc^f1}ouwHdx;fN(w?>!Mgad z=r!vMp`1=UX0rMiv)&t4i3#X149GEHqag%m^n|@Pt%k(bd(G%0b63!5bd`-DK0+<< zjy06JCZ%gLXa?WLalLCzClu?zP`$R&*6QXKLJR$wB|+~|_)j_XGUx&#Mw z1Gdu&5eo^!2mS}AquGa6XF@rGenhJrwED=phETpBvMRt+;}h#vLSaEv9#8Q)SVy6Y2b&y>|cGRjyEW0}gqnX{=576&cdqN>W zcrBGE2Pm};d}=UC{tO2-wQdx4A-9Alz$124NHzFTw*%~2ib|kZCY3-*aZ8|BTmofqtkfZ>w?Y+DF0}@e)(gVwa5NxPKA% zvor8RWa?kIUn%2Z)Gy(FC}Sep{*C($GX~=RKe(ThF%$Ry#r+N$Ut<5uxNkd|i_wvx zu$7nD2pftT`I$DFnA8}VxeyyE>Q&P)!kN{uTdH~!8dEbL#74Tp;TB|e#72-BcVyN> zo04h+kXe~OVWW(?6&jJume?q(I$+woCvzr_r<{5h+%3q&uO?C}sZXG>B(o7VYN_|Y zs4(*gc59^eKx1|0DQq;RMm+OX?AC-D>oU(HX-bXtng3#=xmpW0n=WIc*(Rr-8TE2Tb))6Bq6{;7}Qu949Ldq0j7PR}TDO>Eo|H8On?aFqsy zdrJJNT4X1ohswxJfg`;#J|lZWY`~wYT6Qk>sdF6ctd&RZ%pM$@^`~mpjR710% zd+fz?s+xo4aMB9CfPNX)624;7UV&ydmcvQA?F1359*LVvupCa>9cig(vrZ#e4JU0z zEh1P{vdAWQ23DsX=p}Z6R@unLYB*`Luj)))_e$6L(9BL$1$6gyL{4i2%i*NW#i!uI z9|GF3`R7%`c8zTgvk+~u)=k=i9n>R7BUtMuZP5=z+S#!m&#Ovi7d!UXc~z|k{^e8J zy|vQNZ=P8FgZ{9DP1^F#L`G@^OW35{H=M{+J2v71ENTSCbU{^e;?i?8;B2f$leYSG z>Y30;kNQ9!`;?4qjH0qf4Bts72SLdm_svo0S0sgcEsZc4WZ|Tf2n7FkJuITh&5x<-fWP8(+T&8 zHTp|cYlzih(l!nzEg>G8LNgny!=$}^BazcRVmCwY4p;^z?Y)Oc3-#pq1<<7UFTf7P z&oHtlW6v#Hsb_xA*fy{(xuFwiiKC=V?HN1vm#WnRi@K!ksFaCgiipRP&?Os-x}<&3 zibz}|SkxtL*8n1kp0PofRJH4|d`sHLGe|Rf@yG^4GrKOlnWyb8Bw}j>tGA@>d4Wj8 zOUmLqXnLJKaB#}uJ7{{{A7B^XL1Uj^QZsXv>Q`35`&eczqhHw;@WpXf8^bEuDXVi< zzp`c}SPgCl+-8Yl+P!iY_%L2_;}d^F%2B_?KL1zkYM7z!`OSRIEDsgKtOxK%dIWx| z)c&bAjxsA4N-0PTrg16uf@v1Ux>;s{Ss`QNddvK^YV7KoW@_w{U(AvlpQ~xU(ja!v z`(}lW_w+Td&5q4%Y?g{8Mwo%v!!^y4vCSjQ^o`|4nkQ0HXWTJi;!W4ZE{-v$G`Z={ zJI3EIc~;Nq`M2FNsc*}U#`y6C6DGGdCXq1y`s=2TpD<%q+m@}GPl`<*YmSKZ9&cus z?qKM49b@l}HJ^yxKF(Ya+gsVH6NBGbt`*&<>TG;tyg5u+Q130)qMa%~$!KQ7QtF!p z&nTC=-CknBle?!5bdRO3mn|w7r|ad6N>CcEMXbCN8aKg;| zul{f><)+DFU_nxy`hV(GjEJkpDo!-tQR8C!CYs|bb63SKhQg~daHz5Vlgt*->#j*= zbI0bDfuup(PU@Cz6tE6sp)CnNm62^oK{dEmX#0ot)!bk7N)Q+OOD#3g+pxaL?GOLo z%Z~CH>}5yr?m^o$)=&HNg{(u-H0me)A7@=Eq@}uUjCWX<`e?2WH!fc@kn(6^aE5g$ zjwX6Z$ay$3sf1RN12kk^>Y$02DfMs3y;tcO^)Sx>TFj`eY@8#y*9U0BEG zS>eQN*0bUB4xu;$DLw|dk+yBDhuL5Z>p!xdU>)9dX#1CSDJv!?Z&kRf!oZ=HHuY=n zb~n1DKzsyJGE8PLmJOspSdb0ou^wSZA=a0%9{1@Fv!3wj>sU9ORyMhCe;US{45Z+f z=sQ@Ka$lnFlK|{TPSPW+@AT=HS(l1lc&9~MIY{=n68n4xjaip+Uee!YU5a^$K7#dM zeSW61E_J-Pzhf+7aN1|^2V>A9iLH)`b1w~ zd~zb{Qk_fs!}Gix0@Hm4_{0@7kkVXYfKP-${VrdBd?pa;5ud(;^~FB@0PD+JJ2uT! z0{p>13UY~_0e7?*K&o+xUW;|9#U*-2)}QeO9?ZJb;YxM$AAI-0fXi?dof8q(r3RM- zh_NmexI}-I_3ggEyI7a%Thib8k-;9H!3EZ(@|GBsg7<4&i37g=cz=(2(x-Q4{g6)| z;p&cY+y`!91F5XlkPeVxEMi^iYKe}IV4-8*#yymxZ(u#)(|3vgw%8xmUkrYb00fHl zvl76kXTiG^22S|&+N?_^YtVCI!dwP6tP84O@O;nOEefbM#LITFC9KPdh+-7$=pB!C9s+e8Uq>jA!( z06rayz|ji%^dQ{uqn=>>4a41PqfYn#xo!Xf9oWF`q3eTKH+t&&WC`HY?_ymlT8aOa z;=i};zW)nYCjt8C0r2rFGy|WG4+WqZ_tpF3pQ@rRb*#j{S<2O=iWTUv{;*YMkm#p7 z%3(dyU)TGxE(NS4z&HsoK<|I2`1k3{Ngao)o zcl4G77@_NXB)~{rKP3Kj-7)@^0Hbt+a;5ns8m;S1SU0ZK^`5LJeEPMlN5<&=Zzmn@ z|Lw6lSSA6+>H50mke7KWE(z>-tggKLK<+|7EFF8F$7B1RlLI>ye2z%0>NK zvTje(^?s}ylXZQ9`1j~^{mqsD*Xaf;CBPJ2e_jGy@9JU0-L|qW)ulxLighV1CHk>4 zFn_%KLQ`$>AV8Jn%hIP;WIgHAo3n1;p!?~~dfcavVcnSK=mxhj2v5`XC9EfW`V*{6 zB`KM}TdYeNDbYV=U5ZGBY5fiOogD^JLrM((W?d>siC(50=ZTwbu!ipo=_lN@vM$A= zMDNbJl#UYJ!CG>32&UWQLcqF(PAeEuSQId763x!*lej3I_)}<(v=vY|}XDlV5 zL~qEt6oeAp2A%Hzr5==k5o{2iVH>!G>8D{#XI)A`iN2Wi&`g_pivBq35ug4R>&cn6 zd;W{T9tKhZO7uglO93d+FSBmUwhi3E^b`J%tfIRTVV~Zd^+b{G#y9#f2;F6qi$3gV z4C@h}ejDpapT2~3`)=LO{xj0 zIf!*Bza;u~tV``B(dV)*g_l65_{KvFj3s*Dmst<{^bc51`1BuGmtsp2_$=#EX-V{~ zst_NKnUq-)P^YS^ON}MbJF_kYmP8-Qx>Q#Z{YKWYv=VNjFJL|4_`o9!q^Ob@yv}-L zx$fu_)}@@1^#6r*dxhIS1i^9pi}f(;PKac~C{@j!al~g(kM+1u@639_rw?X5>C>mO zZro>6M2_niSn-Z78yy&{Shs!pORR@|`gYbMKK)zP<39Z~>2Uv_@PV}Id`|fE8mt@l zYcnv~vL5p316a3x`b5^lsN?z1OJU4r5b+rlvL5&8&#|8H>04M&`t+|@Hwud@QnD_A#H7S8|&`Yh`q zpT3!O+oylYdU&OyJ37W7;xjO7x+@X)=~Y-y`1Dq+Cw+Q<){O@^u7kseZ6bq^09Q8d zV%_%XD_IZw^mVL9e0qZQxKDTXGf4QrY1WfIJw4>Egb}rAh|qLjVTUebpWcCW+o$Kd zx?_ZWU@99#e0qfSIO}x{cU#4J(x<<~x|AQ1{@Yo1YY#bwAz(j)_=C2Ao9HJ)?#!g> zkm!M0JmZIK>|WHr8tYPTNcy*CJ?`xf@r`~Al3oD%cnPq|hE{Qa84|#!uaE#f{TcD^ z)87T1?*FBQ@k4gZaenkTK^a{0kg;wi+nz0^UZR7llXV!~B+-Gnt>q(z} zn*?}R53p1M`1H8=FVfxk#zqNH1ZZ5w9tp5U5Ad4=@ag#1t9TW}eR|nCd=B~a#twtf zBYJ=ytcQL2Xx8IC{ZjB2H9`@;XN&ug}Li}sG18*J@;0ZmzW(nZa@%Jlf z20s0S1n}vBdTxKI_5wWrc*7y4KLe@`% z4)cfKHsrwT7-TI4r?8&=lsmhD9MNa7E){V^FJwLRqGQtt1*~J>7Q=x*P$6mUgt z{UqyB0!Q@JChkf|{hQTp{)1n^WFWBl>XGrK*kSH?tn!s2}1*tlOJVhxHeO#~36D6zgxYE|qMg{~p#u@8|&zv!3wj zS6G+&HRK16f5m3*v61RE5}*a^Qo2U;Jl5^adf*AHCw=-|tV_Wf@e>8zz5m~;J9>!? zq*jd>yw7?#q4&q<4$)=2P1nz{9{1@bo4ft(?KaN8c&QsONN%@LE;=+e>yaJ0K8kgz zN+SckjddwWBl{%D)ik83s~~Mhvi;9nLJi(+yk~`r`Hl>r!w=^rNgxwHeW` zur8%$L@$r^<|x1}n;Z*h!g|uD=dvypW~BcJ*25p_er^{3K7AqUPSOV+kpLg*j$V@h zKK&yJ;M0?=OD!20=mqirG5IgP|1X*2u0+@cMV|}mu^#v7U09a_G7?}Y>!DBd2}~3J znhxjRdI05YO^jCVnpxA zx|D|zJ)d={4I}#X;(w3rp8o>oNdN%2iT;oT@ab6g4o}{sPv0Q{KGXdi5dX!xd;Oo0 z0L6d?klBg@`1IPWO92=eXeZXC`itm8SeMc-qEBlD@o5Ho^^x8q0Y2CDH4?z5V=*_n zjD0#jUx57k^qHS}0J?Yc21Rk!0)NEn@j&YEIRBVyJXIYnWEuv?(aUF&C>w#;r zE_GU@e+Sm3NQ>zB7op0)-~TzFJDS1EdwdYBKm38r5KCoX>Hw=kV-6~*I-@Bu!xR-?n{RtX&bo3;U8Up0~myUvOy{y z&?MFqKK(A%!#~^Dy=Vd}SvP*s^>wVrefrk65FbZm|Ee2&%?3%Ieu8zWwGxNmxTUmn zXC{SK;-nfzRo11-is-Fa4mhj713w1ZXdM`+~V}pFz#nP>C>NM zT}rCN-TVh1Fc^f6+2leTVUavsp@dIA#d`R--aoCq+ut~$>or-A`*f#01F4`Qfv;v= z%BP5aJ?m0CMRbRCshc8tjCCoRBKoVY4&VR(VH>!`>8D}rVguuhO^WD0vL5&87g)Fd zbo-AcEBKS(4(>|CeR>_%-C`)P{$kLPfs{fK{c6^w42tO2u`V@GM8BJLDS#sSO4gr(eb^siVqF6c8p&U)CVTOIiv^66DTckll%>W<*gaot4W)ALxD zDkn0a@vKXU6VYd|F7-`BU%|R@$#&0w0nac9U(yHkF6#-OzK?aOX(E1(vJM4J4BSLF zI=K^*VkV>A{0ASw7)U7-F=)=Z)G-mgH|xf~dVn#khkg3(tS5Z>y$*xWW!=$}tVewM zCf1Wa{WI3>E4rUUtjB%&zpTUh=fVONFHyP9?h=K4dQ;XDKD`&~A*K5n!+ON0-@$s) z)t#bavz&o#>W-daJ?_)rW8JXy{$H{l_UXr2PiQ*KKc$O1<4}t3s2b}LpWcS`q)#8f zx*gE{OlCdq)90X$-~St_y1|2N5N2KO-Cht!K0U#@6c>^HSgjV{JKV}5#kcdv#Xr;s zf%z8$v#Vx762NEhmjo!G2gvU3u7p$r5kC!B zkNf&}V?C+sjxn4;h--F;qnjjvPhTJbeEJ#*;L|sVe=gG@{y!oe?*Fmu2W|p>k^nya zFA3n&OWS-7W$S(#u^#s6xvW!_562UD6a%U8Ap^RV^$?fi5Pd1@Qr$!JCs~)$9-_Z3 z{yly$zVSH&De55xc=L)^N4ShWGfds6$9;Nb){{ORpZ!T!85hY2K}_8GV*Wv3`@mQ> z2>bNgS&#VirL4z&`V*`teEOTLC(Amp2V01K8pbCKjB>jE6YC+Levx(CrqbR=0vWydD)8!f{6h?EF95wg>tUZhi1mn1pTc_Fr(=~qT+xJ2 zUj;hd|0jLm6*e#`=`+~LddR0AWZm}Z=UET?^pd^Z0Yxh1y63+fg8B^NK7($oCww|q z>BE^Nefo6P4a`WeiT}l{hl+H*{vKyw7Xh*}-eNuM)Az6*VIBUfm$u(nPx$nISeJ?z z(!VSg&!Y@j#T}`D#;i*%4AFC0Px$(eWZkH$`?*E@`}D=EJ5m5c0z57OdFr$(tAzx-T>r$se^iixEb&3Lz#ckr>r!VUV@o~lxAHYI=bO?O4`p4-P>6n$1gNJEbdmV4@9K^iJkCJs zOaytUx3DfnCPY8Tx>T4D{W9xPMu_DsHih*F>UjR!u5K)5knkBi#d?zUJnp}pbt!#NhV_H2OWgzMf0=bD zdVu}u`l~X~ote}&kaMCl>r%oXlLL%oUFsJ||Jkfd?E>k)ighVbkfU5j8wc|Jzmy_? z0n+v*8%P-fF*wJ%)F6=lSl|v%u6T}nXrzB@)}{J@^v`GAZsoWJvP1<8q?Ujz>2lVk zWPr^xc!_l>3?OIwhpfx<|06uHBdp6){zGp5gD;`3=98as2m?N4DxHtX_e z{x?|1dSkc}@&x{7tk04D?OgxMS$7^~AkWj6t6&rB^4NS?q5Z7O!|`Q>&ay5~#+Ux( zU`cR5@>qQ7pX2H<{|@ema(G1fY#o)hdSzpe2g!OFJ*RdY=_5YCdB3={1u-=9TbdL29KM=kO>!pYA{lCpX44MMKV;1ol(ak2>+;li%gujK z>;USPG z#7ip0+HQ1xcXgLkG8z_kLtP#XFMb-cF3*LRbEp^V{pG3fk|@S8kVnFcqgkxWEFO<$=D#x;%s0)!};nnn62uBnD?#@8Z*o zo+rw>oUBF96ZPpu&lC0O#m^IEP=iNW^gL0YUi3UspT6GYbIhj~Jx??@mpqIAqUVW% zj`{4r&l6>XSv;Vk=ZUf&V%@elFze-5FM6J64>vIU{{?MD&l6=G&Pj@I#Mx0k1G##N zo+rxs7u}-z^(^Yob}k`3^+GD2q=$mVWeloI3yaX~*Zdf3~lG`fxP+?^Bqog02i$ z?6B@1%MFw^n5PlpAza4;ISlIv&mT3``TQJ=t=wi-?AI2|5c?;V%kCDZxiczMuD?DMzKS6g zI?_4J(3k>uYD%ouc6hnVZQV~Vm7hi%n2JBftJJyjM;yvq(gVG=*tlW4`Ps0Ik5;ti zs*PPLTRqK&xHF*dukUt`*j`aIX)0ylaLxBL}S5$vRf!@<;A-*>N~vMH>#{{{b`L)=&Td diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c index 99983a1ad0..be52b9698c 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c @@ -6,6 +6,7 @@ #include "../../nrLDPC_bnProc.h" #define NB_Z 51 void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t,int); +void nrLDPC_cnProc_BG2_generator_AVX512(uint16_t,int); int main() { uint16_t Z[NB_Z]={2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384}; @@ -14,6 +15,7 @@ int main() for(int i=0; i #include - void nrLDPC_cnProc_BG1_Z384_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { //Process group with 3 BNs __m256i ymm0, min, sgn,ones,maxLLR; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c new file mode 100644 index 0000000000..1e53c0b419 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z104_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<20;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<65;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<65;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<65;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<65;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c new file mode 100644 index 0000000000..f21b79d1ed --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z10_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c new file mode 100644 index 0000000000..7b79cfed9a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z112_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<21;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<70;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<70;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<70;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<70;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c new file mode 100644 index 0000000000..6d5d48e2a8 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z11_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c new file mode 100644 index 0000000000..0b2f5c8b90 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z120_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<23;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<75;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<75;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<75;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<75;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c new file mode 100644 index 0000000000..f91551d026 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z128_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<24;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c new file mode 100644 index 0000000000..1d1969a66d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z12_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c new file mode 100644 index 0000000000..54b1113528 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z13_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c new file mode 100644 index 0000000000..0d7a5f6ced --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z144_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<27;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c new file mode 100644 index 0000000000..9c393a67e8 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z14_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c new file mode 100644 index 0000000000..2200509e3e --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z15_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c new file mode 100644 index 0000000000..8c697a8039 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z160_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<30;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<100;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<100;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<100;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<100;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c new file mode 100644 index 0000000000..6077b55309 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z16_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c new file mode 100644 index 0000000000..4d0707402d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z176_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<33;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<110;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<110;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<110;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<110;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c new file mode 100644 index 0000000000..e0c495901b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z18_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c new file mode 100644 index 0000000000..71cde9a4c9 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z192_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<36;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<120;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<120;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<120;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<120;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c new file mode 100644 index 0000000000..f2d8b336c9 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z208_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<39;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<39;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<39;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<130;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<130;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<130;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<130;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c new file mode 100644 index 0000000000..e6a6d9f2ba --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z20_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c new file mode 100644 index 0000000000..149794c311 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z224_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<42;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<42;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<42;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<140;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<140;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<140;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<140;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c new file mode 100644 index 0000000000..038f86a4f3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z22_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c new file mode 100644 index 0000000000..37ff84092c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z240_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<45;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<150;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<150;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<150;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<150;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c new file mode 100644 index 0000000000..12d647ce67 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z24_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c new file mode 100644 index 0000000000..ce740c10d3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z256_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<48;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<160;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<160;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<160;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<160;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c new file mode 100644 index 0000000000..78b32626a5 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z26_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c new file mode 100644 index 0000000000..d435c23a2e --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z288_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<54;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c new file mode 100644 index 0000000000..2711bc1b28 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z28_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c new file mode 100644 index 0000000000..9506ba9d3a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z2_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c new file mode 100644 index 0000000000..926101fc85 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z30_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c new file mode 100644 index 0000000000..2d849aa333 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z320_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<60;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<200;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<200;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<200;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<200;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c new file mode 100644 index 0000000000..d2943f6e51 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z32_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c new file mode 100644 index 0000000000..1e41cb092d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z352_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<66;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<66;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<66;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<220;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<220;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<220;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<220;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c new file mode 100644 index 0000000000..8444317af6 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z36_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c new file mode 100644 index 0000000000..e4e671b5c7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z384_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<72;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<240;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<240;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<240;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<240;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c new file mode 100644 index 0000000000..bcb39f8809 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z3_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c new file mode 100644 index 0000000000..c077b8b93a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z40_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c new file mode 100644 index 0000000000..ff9292d65c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z44_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c new file mode 100644 index 0000000000..b5d8c35f49 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z48_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c new file mode 100644 index 0000000000..adde2b472b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z4_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c new file mode 100644 index 0000000000..0140bbab21 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z52_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c new file mode 100644 index 0000000000..0a7cc1a0d8 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z56_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c new file mode 100644 index 0000000000..7e911a2c2d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z5_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c new file mode 100644 index 0000000000..0f831b82de --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z60_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c new file mode 100644 index 0000000000..084798cd21 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z64_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c new file mode 100644 index 0000000000..91be774147 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z6_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c new file mode 100644 index 0000000000..20477549de --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z72_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<14;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c new file mode 100644 index 0000000000..3b22c5e125 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z7_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c new file mode 100644 index 0000000000..14fb4d0a7c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z80_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<15;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c new file mode 100644 index 0000000000..25bbcb50d2 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z88_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<17;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c new file mode 100644 index 0000000000..cadca0e876 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z8_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c new file mode 100644 index 0000000000..1ca757bfa7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z96_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<18;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c new file mode 100644 index 0000000000..b0dc4d483b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_13_AVX2.c @@ -0,0 +1,823 @@ +#include +#include +void nrLDPC_cnProc_BG2_Z9_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[144+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[72+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[145+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[73+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[72+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[144+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[73+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[145+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[936+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[936+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1176+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1284+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1392+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1608+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1500+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1176+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1284+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1392+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1500+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1608+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1716+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1752+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1788+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1824+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1896+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1860+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1716+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1752+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1788+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1824+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1860+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1896+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1956+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1980+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2004+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2028+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2100+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2076+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1956+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1980+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2004+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2028+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2076+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2100+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2124+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2148+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2196+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2220+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2244+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2268+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2340+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2316+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2124+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2148+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2196+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2220+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2244+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2268+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2316+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2340+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_13_AVX512.c new file mode 100644 index 0000000000..028fc8acd6 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z104_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<21;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<66;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<66;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<66;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<66;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_13_AVX512.c new file mode 100644 index 0000000000..454c57bde2 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z10_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_13_AVX512.c new file mode 100644 index 0000000000..471c209c13 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z112_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<22;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<71;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<71;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<71;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<71;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_13_AVX512.c new file mode 100644 index 0000000000..7bdaecb163 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z11_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_13_AVX512.c new file mode 100644 index 0000000000..f27234e514 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z120_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<24;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<76;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<76;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<76;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<76;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_13_AVX512.c new file mode 100644 index 0000000000..ed82005362 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z128_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<25;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_13_AVX512.c new file mode 100644 index 0000000000..4a6f4e84c7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z12_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_13_AVX512.c new file mode 100644 index 0000000000..fddad47a3a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z13_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_13_AVX512.c new file mode 100644 index 0000000000..53fc972914 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z144_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<28;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_13_AVX512.c new file mode 100644 index 0000000000..c335d28ea0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z14_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_13_AVX512.c new file mode 100644 index 0000000000..f03c575141 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z15_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_13_AVX512.c new file mode 100644 index 0000000000..6a4d58f191 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z160_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<31;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<101;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<101;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<101;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<101;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_13_AVX512.c new file mode 100644 index 0000000000..bd10af445e --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z16_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_13_AVX512.c new file mode 100644 index 0000000000..55e116b51f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z176_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<34;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<111;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<111;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<111;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<111;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_13_AVX512.c new file mode 100644 index 0000000000..712ec87469 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z18_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_13_AVX512.c new file mode 100644 index 0000000000..eda5b6a463 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z192_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<37;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<121;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<121;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<121;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<121;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_13_AVX512.c new file mode 100644 index 0000000000..9a1081c951 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z208_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<40;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<40;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<40;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<131;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<131;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<131;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<131;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_13_AVX512.c new file mode 100644 index 0000000000..7a42b26ad1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z20_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_13_AVX512.c new file mode 100644 index 0000000000..1863faff1c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z224_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<43;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<43;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<43;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<141;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<141;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<141;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<141;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_13_AVX512.c new file mode 100644 index 0000000000..fc8ec65f5b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z22_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_13_AVX512.c new file mode 100644 index 0000000000..7c2b22ab84 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z240_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<46;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<151;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<151;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<151;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<151;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_13_AVX512.c new file mode 100644 index 0000000000..a7e29917dc --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z24_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_13_AVX512.c new file mode 100644 index 0000000000..8467ccc0ef --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z256_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<49;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<161;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<161;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<161;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<161;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_13_AVX512.c new file mode 100644 index 0000000000..dd9c501e23 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z26_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_13_AVX512.c new file mode 100644 index 0000000000..080ef69200 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z288_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<55;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_13_AVX512.c new file mode 100644 index 0000000000..04a81d12e9 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z28_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_13_AVX512.c new file mode 100644 index 0000000000..6fd089c473 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z2_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_13_AVX512.c new file mode 100644 index 0000000000..8a67896e39 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z30_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_13_AVX512.c new file mode 100644 index 0000000000..5e1acf0903 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z320_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<61;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<201;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<201;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<201;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<201;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_13_AVX512.c new file mode 100644 index 0000000000..14ce05ac0b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z32_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_13_AVX512.c new file mode 100644 index 0000000000..35c1a730e8 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z352_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<67;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<67;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<67;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<221;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<221;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<221;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<221;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_13_AVX512.c new file mode 100644 index 0000000000..be02e00e7f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z36_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_13_AVX512.c new file mode 100644 index 0000000000..22e55f4543 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z384_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<73;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<241;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<241;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<241;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<241;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_13_AVX512.c new file mode 100644 index 0000000000..f2752744e3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z3_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_13_AVX512.c new file mode 100644 index 0000000000..3d49278c3d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z40_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_13_AVX512.c new file mode 100644 index 0000000000..9bff5a5d51 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z44_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_13_AVX512.c new file mode 100644 index 0000000000..73ff170732 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z48_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_13_AVX512.c new file mode 100644 index 0000000000..174556650b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z4_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_13_AVX512.c new file mode 100644 index 0000000000..4425d37550 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z52_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_13_AVX512.c new file mode 100644 index 0000000000..34476031c1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z56_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_13_AVX512.c new file mode 100644 index 0000000000..4f780cfa67 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z5_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_13_AVX512.c new file mode 100644 index 0000000000..d102d9cda6 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z60_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_13_AVX512.c new file mode 100644 index 0000000000..649ce55fa0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z64_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_13_AVX512.c new file mode 100644 index 0000000000..194c559442 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z6_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_13_AVX512.c new file mode 100644 index 0000000000..fd82e34130 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z72_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<15;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_13_AVX512.c new file mode 100644 index 0000000000..0c6b156921 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z7_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_13_AVX512.c new file mode 100644 index 0000000000..2d6c7477bd --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z80_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<16;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_13_AVX512.c new file mode 100644 index 0000000000..6a639f9cb4 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z88_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<18;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_13_AVX512.c new file mode 100644 index 0000000000..8b3b9f9183 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z8_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_13_AVX512.c new file mode 100644 index 0000000000..63631b39b4 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z96_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<19;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_13_AVX512.c new file mode 100644 index 0000000000..b19f2afe39 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_13_AVX512.c @@ -0,0 +1,829 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG2_Z9_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[72+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[72+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[73+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[73+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[144+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[37+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[145+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[576+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[216+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[336+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[456+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[936+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1176+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1284+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1392+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1392+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1500+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1176+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1230+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1284+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1338+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1608+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1716+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1752+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1788+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1824+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1806+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1860+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1716+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1734+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1752+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1770+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1788+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1896+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2124+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2148+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2196+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2220+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2244+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2208+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2268+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2124+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2136+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2148+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2160+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2172+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2184+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2196+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261448+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261484+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[5261376+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261412+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261520+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261460+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[5261472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[5261376+i] = _mm512_sign_epi16(min, sgn); + } +}