From 559e8fdcd2b8407f24f8566897b85a5915e5521a Mon Sep 17 00:00:00 2001 From: Sy Date: Wed, 1 Jul 2020 18:37:52 +0200 Subject: [PATCH] degradation of performance in BLER fixed | bnProc & bnProcPc unrolled | small improvement in times --- .../CODING/nrLDPC_decoder/nrLDPC_decoder.c | 110 +- .../generator_bnProc/sauvegarde.tar.gz | Bin 8704 -> 0 bytes .../generator_bnProc_avx512/Makefile | 27 + .../bnProc_gen_BG1_avx512.c | 1185 +++++++++ .../bnProc_gen_BG2_avx512.c | 1184 +++++++++ .../generator_bnProc_avx512/bnProc_gen_avx512 | Bin 0 -> 57368 bytes .../generator_bnProc_avx512/main.c | 26 + .../generator_cnProc/sauvegarde.tar.gz | Bin 4299 -> 0 bytes .../generator_cnProc_avx512/sauvegarde.tar.gz | Bin 3797 -> 0 bytes .../bnProc/nrLDPC_bnProc_BG2_R13_AVX2.c | 440 ---- .../bnProc/nrLDPC_bnProc_BG2_R15_AVX2.c | 799 ------ .../bnProc/nrLDPC_bnProc_BG2_R23_AVX2.c | 153 -- .../bnProcPc/nrLDPC_bnProcPc_BG2_R89_AVX2.h | 192 -- .../nrLDPC_bnProc_BG1_R13_AVX512.h | 787 ++++++ .../nrLDPC_bnProc_BG1_R23_AVX512.h | 272 ++ .../nrLDPC_bnProc_BG1_R89_AVX512.h | 118 + .../nrLDPC_bnProc_BG2_R13_AVX512.h | 440 ++++ .../nrLDPC_bnProc_BG2_R15_AVX512.h | 799 ++++++ .../nrLDPC_bnProc_BG2_R23_AVX512.h | 153 ++ .../cnProc/nrLDPC_cnProc_BG1_R13_AVX2.c | 2346 ----------------- .../cnProc/nrLDPC_cnProc_BG1_R23_AVX2.c | 2097 --------------- .../cnProc/nrLDPC_cnProc_BG1_R89_AVX2.c | 1177 --------- .../cnProc/nrLDPC_cnProc_BG2_R13_AVX2.c | 777 ------ .../cnProc/nrLDPC_cnProc_BG2_R15_AVX2.c | 832 ------ .../cnProc/nrLDPC_cnProc_BG2_R23_AVX2.c | 696 ----- .../nrLDPC_llr2CnProcBuf_BG1_AVX2.h | 1040 -------- 26 files changed, 5087 insertions(+), 10563 deletions(-) delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/Makefile create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_BG1_avx512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_BG2_avx512.c create mode 100755 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_avx512 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/main.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/sauvegarde.tar.gz delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_R13_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_R15_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_R23_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_R89_AVX2.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R13_AVX512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R23_AVX512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R89_AVX512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R13_AVX512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R15_AVX512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R23_AVX512.h delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_R13_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_R23_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_R89_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_R13_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_R15_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_R23_AVX2.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/llr2CnProcBuf/nrLDPC_llr2CnProcBuf_BG1_AVX2.h diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c index 6061c397fb..ffcad00af4 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 @@ -48,7 +49,6 @@ #include "nrLDPC_tools/ldpc_gen_files/cnProc_avx512/nrLDPC_cnProc_BG2_R13_AVX512.h" #include "nrLDPC_tools/ldpc_gen_files/cnProc_avx512/nrLDPC_cnProc_BG2_R23_AVX512.h" - #else /*---------------------------------------------------------------------- @@ -81,7 +81,18 @@ #include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_R23_AVX2.h" //bnProc---------------------------------------------------------------- + +#ifdef __AVX512BW__ //BG1------------------------------------------------------------------- +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R13_AVX512.h" +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R23_AVX512.h" +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG1_R89_AVX512.h" +//BG2 -------------------------------------------------------------------- +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R15_AVX512.h" +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R13_AVX512.h" +#include "nrLDPC_tools/ldpc_gen_files/bnProc_avx512/nrLDPC_bnProc_BG2_R23_AVX512.h" + +#else #include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_R13_AVX2.h" #include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_R23_AVX2.h" #include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_R89_AVX2.h" @@ -90,6 +101,7 @@ #include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_R13_AVX2.h" #include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_R23_AVX2.h" +#endif @@ -237,7 +249,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP } } - } + } else { switch (R) @@ -330,7 +342,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP break; } } - } + } else { switch (R) @@ -380,41 +392,65 @@ if (BG==1) { case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 89: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R89_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R89_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } } - } + } else { switch (R) { case 15: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R15_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R15_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } @@ -501,7 +537,7 @@ if (BG==1) } } - } + } else { switch (R) @@ -592,7 +628,7 @@ if (BG==1) break; } } - } + } else { switch (R) @@ -634,47 +670,72 @@ if (BG==1) #endif // nrLDPC_bnProc(p_lut, p_procBuf, Z); + if (BG==1) { switch (R) { case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 89: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R89_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R89_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } } - } + } else { switch (R) { case 15: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R15_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R15_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } @@ -684,7 +745,6 @@ if (BG==1) - #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProc); #endif @@ -777,7 +837,7 @@ if (BG==1) } } - } + } else { switch (R) @@ -868,7 +928,7 @@ if (BG==1) break; } } - } + } else { switch (R) @@ -915,47 +975,72 @@ if (BG==1) //nrLDPC_bnProc(p_lut, p_procBuf, Z); + if (BG==1) { switch (R) { case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 89: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG1_R89_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG1_R89_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } } - } + } else { switch (R) { case 15: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R15_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R15_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 13: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R13_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R13_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } case 23: { + #ifdef __AVX512BW__ + nrLDPC_bnProc_BG2_R23_AVX512(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #else nrLDPC_bnProc_BG2_R23_AVX2(p_procBuf->bnProcBuf, p_procBuf->bnProcBufRes,p_procBuf->llrRes, Z); + #endif break; } @@ -964,7 +1049,6 @@ if (BG==1) } - #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProc); #endif @@ -1052,5 +1136,3 @@ if (BG==1) - - diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz deleted file mode 100644 index 8a0f960339e7fad417d991a6bfa540d9992487ef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8704 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 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/Makefile new file mode 100644 index 0000000000..9ca92c1dda --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/Makefile @@ -0,0 +1,27 @@ +C=gcc +CFLAGS=-W -Wall -mavx2 +LDFLAGS= +EXEC=bnProc_gen_avx512 +SRC= $(wildcard *.c) +OBJ= $(SRC:.c=.o) + +all: $(EXEC) + +bnProc_gen_avx512: $(OBJ) + @$(CC) -o $@ $^ $(LDFLAGS) -O2 + + + +%.o: %.c + @$(CC) -o $@ -c $< $(CFLAGS) -I ${OPENAIR_HOME}/openair1 -g -std=c99 + +.PHONY: clean mrproper + +clean: + @rm -rf *.o + +mrproper: clean + @rm -rf $(EXEC) + +zip: + @tar -zcvf sauvegarde.tar.gz main.c bnProc_gen_BG1_avx512.c bnProc_gen_BG2_avx512.c Makefile diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_BG1_avx512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_BG1_avx512.c new file mode 100644 index 0000000000..07c9a4a4c3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc_avx512/bnProc_gen_BG1_avx512.c @@ -0,0 +1,1185 @@ + + + +#include +#include +#include "../../nrLDPCdecoder_defs.h" +#include "../../nrLDPC_types.h" + + + +void nrLDPC_bnProc_BG1_generator_AVX512(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/bnProc_avx512/nrLDPC_bnProc_BG1_R%s_AVX512.h",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,"static inline void nrLDPC_bnProc_BG1_R%s_AVX512(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) {\n", ratestr[R]); + + const uint8_t* lut_numBnInBnGroups; + const uint32_t* lut_startAddrBnGroups; + const uint16_t* lut_startAddrBnGroupsLlr; + if (R==0) { + + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R13; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R13; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R13; + + } + else if (R==1){ + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R23; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R23; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R23; + } + else if (R==2) { + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R89; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R89; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R89; + } + else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();} + + + //uint32_t M; + //uint32_t M32rem; + // uint32_t i; + uint32_t k; + // Offset to each bit within a group in terms of 32 Byte + uint32_t cnOffsetInGroup; + uint8_t idxBnGroup = 0; + + + + fprintf(fd," __m512i* p_bnProcBuf; \n"); + fprintf(fd," __m512i* p_bnProcBufRes; \n"); + fprintf(fd," __m512i* p_llrRes; \n"); + fprintf(fd," __m512i* p_res; \n"); + fprintf(fd," uint32_t M, i; \n"); + + + +// ===================================================================== + // Process group with 1 CN + // Already done in bnProcBufPc + + // ===================================================================== + + + // ===================================================================== + +fprintf(fd, "// Process group with 2 CNs \n"); + + if (lut_numBnInBnGroups[1] > 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs or parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[1] ); + + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<2; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[2] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + for (k=0; k<3; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[3] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + for (k=0; k<4; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[4] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<5; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[5] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<6; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[6] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<7; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[7] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<8; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[8] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<9; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[9] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<10; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[10] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<11; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[11] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<12; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[12] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<13; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[13] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<14; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[14] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<15; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[15] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<16; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[16] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<17; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[17] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<18; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[18] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<19; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[19] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<20; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[20] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<21; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[21] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<22; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[22] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<23; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[23] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<24; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[24] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<25; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[25] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<26; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[26] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<27; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[27] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<28; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[28] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<29; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[29] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<30; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i +#include +#include "../../nrLDPCdecoder_defs.h" +#include "../../nrLDPC_types.h" + + +void nrLDPC_bnProc_BG2_generator_AVX512(int R) +{ + const char *ratestr[3]={"15","13","23"}; + + 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/bnProc_avx512/nrLDPC_bnProc_BG2_R%s_AVX512.h",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_bnProc_BG2_R%s_AVX512(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) {\n",ratestr[R]); + const uint8_t* lut_numBnInBnGroups; + const uint32_t* lut_startAddrBnGroups; + const uint16_t* lut_startAddrBnGroupsLlr; + if (R==0) { + + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R15; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R15; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R15; + + } + else if (R==1){ + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R13; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R13; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R13; + } + else if (R==2) { + + lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R23; + lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R23; + lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R23; + } + else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();} + + + //uint32_t M; + //uint32_t M32rem; + // uint32_t i; + uint32_t k; + // Offset to each bit within a group in terms of 32 Byte + uint32_t cnOffsetInGroup; + uint8_t idxBnGroup = 0; + + + + fprintf(fd," __m512i* p_bnProcBuf; \n"); + fprintf(fd," __m512i* p_bnProcBufRes; \n"); + fprintf(fd," __m512i* p_llrRes; \n"); + fprintf(fd," __m512i* p_res; \n"); + fprintf(fd," uint32_t M, i; \n"); + + + +// ===================================================================== + // Process group with 1 CN + // Already done in bnProcBufPc + + // ===================================================================== + + + // ===================================================================== + +fprintf(fd, "// Process group with 2 CNs \n"); + + if (lut_numBnInBnGroups[1] > 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs or parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[1] ); + + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<2; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[2] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + for (k=0; k<3; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[3] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + for (k=0; k<4; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[4] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<5; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[5] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<6; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[6] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<7; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[7] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<8; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[8] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<9; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[9] ); + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<10; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[10] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<11; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[11] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<12; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[12] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<13; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[13] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<14; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[14] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<15; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[15] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<16; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[16] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<17; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[17] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<18; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[18] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<19; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[19] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<20; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[20] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<21; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[21] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<22; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[22] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<23; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[23] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<24; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[24] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<25; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[25] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<26; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[26] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<27; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[27] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<28; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[28] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<29; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i 0) + { + // If elements in group move to next address + idxBnGroup++; + + // Number of groups of 32 BNs for parallel processing + fprintf(fd," M = (%d*Z + 63)>>6;\n",lut_numBnInBnGroups[29] );; + + // Set the offset to each CN within a group in terms of 16 Byte + cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>6; + + // Set pointers to start of group 2 + fprintf(fd," p_bnProcBuf = (__m512i*) &bnProcBuf [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + fprintf(fd," p_bnProcBufRes = (__m512i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]); + + // Loop over CNs + for (k=0; k<30; k++) + { + fprintf(fd," p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup); + fprintf(fd," p_llrRes = (__m512i*) &llrRes [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]); + + // Loop over BNs + fprintf(fd," for (i=0;i|c89$|SZ$|ElpRaG(;;sWxc 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 +#include +#define NB_R 3 +void nrLDPC_bnProc_BG1_generator_AVX512(int); +void nrLDPC_bnProc_BG2_generator_AVX512(int); +//void nrLDPC_bnProcPc_BG1_generator_AVX2(int); +//void nrLDPC_bnProcPc_BG2_generator_AVX2(int); + +int main() +{ + int R[NB_R]={0,1,2}; + for(int i=0; i1oxXVQNo07DCVLZ}I7tUEk9nd}ofjgK5t| zuk1+fMBHl74Q)^U|APOS3-H2-h*J7~Nsh-Z) zKjh4(gZS~URk5bg@vmaJQk7u*%Nowd|3*U6;m_g<v00JL4O5$0K`!x_8h7$B@FXCstE|v0lJRK`hARhh8hdpog?(9~G}(N$9V?(DiG% zgdQI(kkl_0-VX-GZD)Y4(Tm={M+Nb^R7ahgu{9}{>dtUIJ45z2dtwZWh2eeAw9x4T z0wV^!2io)d=D@HEC8rcem;R_TG@2EuMP?h@Eysxz3kw;~sHJC%c3;1+9gCrEL}uMJ znMM%$@%`mnblmSX`r`*<#AN?oa4r%{`#scXpsSxRFMXC?bVj2w)R$#|Gz7Mm>OMnZ zN@S|`!~&-ooeYu5%;6AX;fj|sEE0yw#O%VXJRrA%h{k3{lV;Z2lVe1$olpBBT8O$f zY!OW%8f)zd`VCAa4H&2^ua`_&ZZw!q+N0_4V)TA=F?wf>rw?{LkW7(DI+Bcx?#Y{8 z&teHtgC9?HpLerHLn_f*2&XJpL@1UTj}@YcF|Z9L2$#~zkQZdgsb%OjPsSr+-N)%G z=I9n0f-_|L-ND#4prHeuid4zjS-U-yE1G$X9@<{p)g!M!tJY~gbTu8`7#14$(Z!Vw z?T@IE&PCQz=mQbuefkpkbWe*xANzgVn4rlR8J+GOx-lo{cXM(F5GSVs!)JaVR9LDMm?lBX+-$wNQ4X6yI@SZWq(`PsACzV z)~6#kZMce25g#kMdZx%Fnh}M@veSRf-X9lE?Y>iB?r+L1sD;NzEQ_)_6A@q^`;Fz< zjMYLTi$FzvqSfT~BByEUBabAV!Y87B}T3?K}#fg(+f;uUIsF2b7tnI)IzV3RC1Ol zkM1HRFh}0fd7VyRWWprf=b>YDV7eZ#E&~(zJnw~J4xCh9JA*0I4Z(w+`PH<|n}LCD zzJVaN8VZ>4flM_oddI(^6QtnM>(>>cz8Il3HOnpXGnt0(47ZD?pOHye=!^|+jj?+w z=x}^>-F8spw-0ZAb@UZNIz5cRJj1eyM$YZst5I05vXs7=9EIoUzxgjUxs(8kwCX%z za9fBH2AAT5&5gJmj~~$ZD|7_|etd(e#l0qY3tm+GLRPz9UMcVc*1FzG_fa_VDgw-g z*<(6@aqrd%sgmy4vW)Hoq@oTe0Ue2ES-7`>9U;R`pxEPZlR2y5klxT`Y21;kt-Ch= z06$JnL=$@8&>(6bvD-mFfAT+Suu*aDa-T>vPY4!0(m_Y%y}7ZS`Or3RN4`N+?3PWM#)@_6l_icH0zM*M`+6G&YQq zHCh#Kxm9s1U|np@z$d7gsa|w$pWNz7TiJ<3hMOQ^*CF@!HG7{=L|BQ>lQ94eo#&z} zFTzlI|A#dXAum}cH!4ydGHrAU_x>bxxI}WySUKj+xC^E;M2eEKAmrp^X*KhDFJyK* zaJ&}FdpGYM5#RJP#%k_If&SbC;j2jrUkwqyyAFk(QgQJa>P?fDAhg<4TR_ncLTdz> z;lD01e)fIPLVwHBY!=Iuc$-YQDpKMdKuWwGQmUCDCC(Bl@#;va9wJhvz{!)tqe;x; z4mGDqN)Zcv?VR>Cr*GUha2?%~b=JMxyWAe-^qwuW*uC3gB(UF^5#utW)}h9Dg%i@_ zG6mBRBw>vISCHg4!VbYC&Kf2+L6eoFG+BwHNvzLtQpQ?QErs|@uxx2D~2;qnXB~g*!zZQJR9=zZ~PK}oj&7Z=@W^`rqGkRj9GrF=V)W%S)x+B}I zsjybv0jyPXtPNsqHOJaR!&;RGN!1){lVh#6VXTdAu^el2tPO^P!&-H(uvSlswR$Ah z%D(6O>XNUE>P@``U`wCwll@V#Dmy!%SQfFWidfU#r~KS2E@e9JXhr3uVqCt;4ku@YPq zj+PL>;Yb0joXGsFfF=1|>UQBdhMu*3+%eW1eD(_520d%*(Q|FD>6ru1wH%%g4W2a~ ziq&#>P7crdhT%E7#d3Jg;W-!%4xY8l_KP>b%veea%`_$djj%a2V|fWRW2uRy7N9fo z4(SpVjZmW|5pdL1haIK)7H-5<_5}s{oryRZw2%ZcXkjrjXdww?(86M5&_WW(poPWA za0*EP*wvi@>@=^yRd-;6y1E`>V`;A$n+Mrg$|?KMD7(sIHkhq*%ubBiwGCr-Oq1oD zopW|D92{p?_woD%oOqKONAFUrk-W|M-Z8E&wm+)sG@J2F7EiJ zOzw(yxr53|LG-*-uIZqX+)5T4REC^Pl98FYi%NO#T~r2BCU8(G@3DhQd0hvUU_7p@ z>7Y{PIk`;fpi&Mvxm?phWoWBr(|#szlKGj;ohAko?vT^ORLvu#X^$#>$(1$)`=cte z?Z|_4m`IW*@|egRCZb(+nYeX_i8rfk%sO*?gu_HnrS)75dVj{Xb-cqqf67FggrN+f zkaD*$iT*yZPvgrk-l9a?he_>7zKevdj8{9QE5M|7JgHB> zxEhG9&tyB5tF={%?aCDTC)v16s&C@m%Q*c48=1@Ne#ITlG)<6bYcpQc)O(!q;<%fg zNln^{Bf|gtd(H{Y?>Y(YI*BCC!ivuX_Ind+t<~ID3Zd7sCI5TbQfOtv`O=%;izWFM z2Km-SRhHPdK71d@)xZaGj{D3VgK1n@dVOML;`bz^aFw2oV@t2(EEWJXq+JH^om__0 zi(CvWjE6XPk)egb!nY6nVpjP!K|pkxxjVy|duyH=`5klUW*{lflhy(#dMRmmVa2IRg6qPC^F9S)?L6U&5VxkMtrIx<_0fd*mQ7AdMBV z5CN&Yz;O+B<2!KlRElS}D94A7!jV7`j`L0ty|C&FLdjnd%H}1Zr@Xl@cPzNh zdqNq$DYVL~LRr2n#D85V$Y(qsgS+8jFvC}cp8iFlHC_|S`XwQnlTTYuz*-rSR%V=) zYIkhsd=18{HS-#r;Mh#qVaF_Iafef{=$XZLEOX@1)afWH;_T|^bE{Vozi_a1oR60k zrO!{jjy&<&J83U=J8zr*54Z0Aa1AKryFc_)THTAvqu_fTH3){RBjnqA%RIj6`SxDi z_8zZ;1s~+{9Gc9pZf0XIx@8Y_V{gZ{_5!-i<|_?X(TJzDPxP!d<0rM5KBrCngm&kg z113=|@;&xVKy{Vv)DltL+*?al#kmH=7w3A9nIBHQlim}z?mTe~VCFkd^i*2oQ0GUk7~l6J*Wl%C z(DH^|#raN7jy5C(Ebjs;X9&tsCo!QQBnM7Z-Vh+iG-n(k=Zu``l% z`!71}oFBpEs_~zlhj4YRBc9~^h^IXXA3FC2IU?pM%W%$rQlrj)lB6n@$oWrNwW?GV zO?oC_NtLzy{HINXi^grYD_s0|`R3i{#_2EU^cNt1bUGx*4GEV&(0JkPuWv6JzN5mN ztDmng8t8fPcXQC|cB~#cE_X}9$Me6FNVxX0+-;P{B|!jzFCmJ^fKMSQ4FJ* zkDfn%{Pgzf&HL;2Pai+Lot=@hjXI`<(djKZwI{tsw^oCjq)`6!)5oiSL16=AP1^ScEFQFW3h)%6OSUna5cG*onzv`L&r}^*_@a%ii*-roLe(fW>GyQ7ZLd6+n th%Dd!i5&a7e)GsNyYxu5U@SYR4YA>yPq%r001WpdZYjV diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz deleted file mode 100644 index 69e1d9ca37cf707a56e023bb1f4d6c808389dcf2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3797 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 -#include -void nrLDPC_bnProc_BG2_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { - __m256i* p_bnProcBuf; - __m256i* p_bnProcBufRes; - __m256i* p_llrRes; - __m256i* p_res; - uint32_t M, i; -// Process group with 2 CNs - M = (1*Z + 31)>>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [6912]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [6912]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [6912]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [7680]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [7680]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [7296]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [10752]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [10752]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [8064]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [12672]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [12672]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [8448]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [24192]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [24192]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [10368]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [26880]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [26880]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [10752]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [29952]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [29952]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [11136]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [34944]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [34944]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [11520]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [40320]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [40320]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [11904]; - for (i=0;i -#include -void nrLDPC_bnProc_BG2_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { - __m256i* p_bnProcBuf; - __m256i* p_bnProcBufRes; - __m256i* p_llrRes; - __m256i* p_res; - uint32_t M, i; -// Process group with 2 CNs -// Process group with 3 CNs -// Process group with 4 CNs -// Process group with 5 CNs - M = (2*Z + 31)>>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [14592]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [14592]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [14592]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [18432]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [18432]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [15360]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [20736]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [20736]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [15744]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [23424]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [23424]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [16128]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [26496]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [26496]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [16512]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [33408]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [33408]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [17280]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [37248]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [37248]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [17664]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [41856]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [41856]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [18048]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [46848]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [46848]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [18432]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [52224]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [52224]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [18816]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [58368]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [58368]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [19200]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [66816]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [66816]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [19584]; - for (i=0;i -#include -void nrLDPC_bnProc_BG2_R23_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { - __m256i* p_bnProcBuf; - __m256i* p_bnProcBufRes; - __m256i* p_llrRes; - __m256i* p_res; - uint32_t M, i; -// Process group with 2 CNs - M = (3*Z + 31)>>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [1152]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [1152]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [1152]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [3456]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [3456]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [2304]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [9216]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [9216]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [4224]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [13824]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [13824]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [5376]; - for (i=0;i>5; - p_bnProcBuf = (__m256i*) &bnProcBuf [17664]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [17664]; - p_res = &p_bnProcBufRes[0]; - p_llrRes = (__m256i*) &llrRes [6144]; - for (i=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [0]; - p_bnProcBufRes = (__m256i*) &bnProcBufRes [0]; - p_llrProcBuf = (__m128i*) &llrProcBuf [0]; - p_llrProcBuf256 = (__m256i*) &llrProcBuf [0]; - p_llrRes = (__m256i*) &llrRes [0]; - for (int i=0,j=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [1152]; - p_llrProcBuf = (__m128i*) &llrProcBuf [1152]; - p_llrRes = (__m256i*) &llrRes [1152]; - for (int i=0,j=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [3456]; - p_llrProcBuf = (__m128i*) &llrProcBuf [2304]; - p_llrRes = (__m256i*) &llrRes [2304]; - for (int i=0,j=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [9216]; - p_llrProcBuf = (__m128i*) &llrProcBuf [4224]; - p_llrRes = (__m256i*) &llrRes [4224]; - for (int i=0,j=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [13824]; - p_llrProcBuf = (__m128i*) &llrProcBuf [5376]; - p_llrRes = (__m256i*) &llrRes [5376]; - for (int i=0,j=0;i>5; - p_bnProcBuf = (__m128i*) &bnProcBuf [17664]; - p_llrProcBuf = (__m128i*) &llrProcBuf [6144]; - p_llrRes = (__m256i*) &llrRes [6144]; - for (int i=0,j=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [16128]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [16128]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [16128]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [17664]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [17664]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [16512]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [19584]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [19584]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [16896]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [24192]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [24192]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [17664]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [34944]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [34944]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [19200]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [44160]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [44160]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [20352]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [47616]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [47616]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [20736]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [62976]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [62976]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [22272]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [75648]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [75648]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [23424]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [94080]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [94080]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [24960]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [99072]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [99072]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [25344]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [109824]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [109824]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [25728]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [3456]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [3456]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [3456]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [4224]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [4224]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [3840]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [9984]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [9984]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [5760]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [14592]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [14592]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [6912]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [28032]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [28032]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [9600]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [46464]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [46464]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [12672]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [50688]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [50688]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [13056]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [384]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [384]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [384]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [2688]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [2688]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [1536]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [26880]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [26880]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [9600]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [28416]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [28416]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [9984]; + for (i=0;i +#include +void nrLDPC_bnProc_BG2_R13_AVX512(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { + __m512i* p_bnProcBuf; + __m512i* p_bnProcBufRes; + __m512i* p_llrRes; + __m512i* p_res; + uint32_t M, i; +// Process group with 2 CNs + M = (1*Z + 63)>>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [6912]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [6912]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [6912]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [7680]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [7680]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [7296]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [10752]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [10752]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [8064]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [12672]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [12672]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [8448]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [24192]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [24192]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [10368]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [26880]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [26880]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [10752]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [29952]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [29952]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [11136]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [34944]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [34944]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [11520]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [40320]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [40320]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [11904]; + for (i=0;i +#include +void nrLDPC_bnProc_BG2_R15_AVX512(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { + __m512i* p_bnProcBuf; + __m512i* p_bnProcBufRes; + __m512i* p_llrRes; + __m512i* p_res; + uint32_t M, i; +// Process group with 2 CNs +// Process group with 3 CNs +// Process group with 4 CNs +// Process group with 5 CNs + M = (2*Z + 63)>>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [14592]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [14592]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [14592]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [18432]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [18432]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [15360]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [20736]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [20736]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [15744]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [23424]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [23424]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [16128]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [26496]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [26496]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [16512]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [33408]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [33408]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [17280]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [37248]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [37248]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [17664]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [41856]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [41856]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [18048]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [46848]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [46848]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [18432]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [52224]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [52224]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [18816]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [58368]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [58368]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [19200]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [66816]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [66816]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [19584]; + for (i=0;i +#include +void nrLDPC_bnProc_BG2_R23_AVX512(int8_t* bnProcBuf,int8_t* bnProcBufRes, int8_t* llrRes, uint16_t Z ) { + __m512i* p_bnProcBuf; + __m512i* p_bnProcBufRes; + __m512i* p_llrRes; + __m512i* p_res; + uint32_t M, i; +// Process group with 2 CNs + M = (3*Z + 63)>>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [1152]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [1152]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [1152]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [3456]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [3456]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [2304]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [9216]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [9216]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [4224]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [13824]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [13824]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [5376]; + for (i=0;i>6; + p_bnProcBuf = (__m512i*) &bnProcBuf [17664]; + p_bnProcBufRes = (__m512i*) &bnProcBufRes [17664]; + p_res = &p_bnProcBufRes[0]; + p_llrRes = (__m512i*) &llrRes [6144]; + for (i=0;i -#include -static inline void nrLDPC_cnProc_BG1_R13_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; - M = (1*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i -#include -static inline void nrLDPC_cnProc_BG1_R23_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; - M = (1*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i -#include -static inline void nrLDPC_cnProc_BG1_R89_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; - M = (1*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i -#include -static inline void nrLDPC_cnProc_BG2_R13_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; -//Process group with 4 BNs - M = (8*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i -#include -static inline void nrLDPC_cnProc_BG2_R15_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; - M = (6*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i -#include -static inline void nrLDPC_cnProc_BG2_R23_AVX2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { -//Process group with 3 BNs - __m256i ymm0, min, sgn,ones,maxLLR; - ones = _mm256_set1_epi8((char)1); - maxLLR = _mm256_set1_epi8((char)127); - uint32_t M; - int8_t* cnProcBuf = p_procBuf->cnProcBuf; - int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; -//Process group with 4 BNs - M = (1*Z + 31)>>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i>5; - for (int i=0;i -#pragma omp declare simd notinbranch -static inline void nrLDPC_llr2CnProcBuf_BG1_AVX2(t_nrLDPC_lut* p_lut, int8_t* llr, int8_t* cnProcBuf, uint16_t Z) { - const uint16_t (*lut_circShift_CNG3) [lut_numCnInCnGroups_BG1_R13[0]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[0]]) p_lut->circShift[0]; - const uint16_t (*lut_circShift_CNG4) [lut_numCnInCnGroups_BG1_R13[1]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[1]]) p_lut->circShift[1]; - const uint16_t (*lut_circShift_CNG5) [lut_numCnInCnGroups_BG1_R13[2]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[2]]) p_lut->circShift[2]; - const uint16_t (*lut_circShift_CNG6) [lut_numCnInCnGroups_BG1_R13[3]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[3]]) p_lut->circShift[3]; - const uint16_t (*lut_circShift_CNG7) [lut_numCnInCnGroups_BG1_R13[4]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[4]]) p_lut->circShift[4]; - const uint16_t (*lut_circShift_CNG8) [lut_numCnInCnGroups_BG1_R13[5]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[5]]) p_lut->circShift[5]; - const uint16_t (*lut_circShift_CNG9) [lut_numCnInCnGroups_BG1_R13[6]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[6]]) p_lut->circShift[6]; - const uint16_t (*lut_circShift_CNG10)[lut_numCnInCnGroups_BG1_R13[7]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[7]]) p_lut->circShift[7]; - const uint16_t (*lut_circShift_CNG19)[lut_numCnInCnGroups_BG1_R13[8]] = (uint16_t(*)[lut_numCnInCnGroups_BG1_R13[8]]) p_lut->circShift[8]; - const uint8_t (*lut_posBnInCnProcBuf_CNG3) [lut_numCnInCnGroups_BG1_R13[0]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[0]]) p_lut->posBnInCnProcBuf[0]; - const uint8_t (*lut_posBnInCnProcBuf_CNG4) [lut_numCnInCnGroups_BG1_R13[1]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[1]]) p_lut->posBnInCnProcBuf[1]; - const uint8_t (*lut_posBnInCnProcBuf_CNG5) [lut_numCnInCnGroups_BG1_R13[2]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[2]]) p_lut->posBnInCnProcBuf[2]; - const uint8_t (*lut_posBnInCnProcBuf_CNG6) [lut_numCnInCnGroups_BG1_R13[3]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[3]]) p_lut->posBnInCnProcBuf[3]; - const uint8_t (*lut_posBnInCnProcBuf_CNG7) [lut_numCnInCnGroups_BG1_R13[4]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[4]]) p_lut->posBnInCnProcBuf[4]; - const uint8_t (*lut_posBnInCnProcBuf_CNG8) [lut_numCnInCnGroups_BG1_R13[5]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[5]]) p_lut->posBnInCnProcBuf[5]; - const uint8_t (*lut_posBnInCnProcBuf_CNG9) [lut_numCnInCnGroups_BG1_R13[6]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[6]]) p_lut->posBnInCnProcBuf[6]; - const uint8_t (*lut_posBnInCnProcBuf_CNG10)[lut_numCnInCnGroups_BG1_R13[7]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[7]]) p_lut->posBnInCnProcBuf[7]; - const uint8_t (*lut_posBnInCnProcBuf_CNG19)[lut_numCnInCnGroups_BG1_R13[8]] = (uint8_t(*)[lut_numCnInCnGroups_BG1_R13[8]]) p_lut->posBnInCnProcBuf[8]; - int8_t* p_cnProcBuf; - uint32_t idxBn = 0; - p_cnProcBuf= &cnProcBuf[0]; - idxBn = lut_posBnInCnProcBuf_CNG3[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG3[0][0]); - p_cnProcBuf= &cnProcBuf[384]; - idxBn = lut_posBnInCnProcBuf_CNG3[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG3[1][0]); - p_cnProcBuf= &cnProcBuf[768]; - idxBn = lut_posBnInCnProcBuf_CNG3[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG3[2][0]); - p_cnProcBuf= &cnProcBuf[1152]; - idxBn = lut_posBnInCnProcBuf_CNG4[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[0][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[0][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[0][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[0][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[0][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[0][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[0][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[3072]; - idxBn = lut_posBnInCnProcBuf_CNG4[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[1][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[1][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[1][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[1][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[1][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[1][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[1][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[4992]; - idxBn = lut_posBnInCnProcBuf_CNG4[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[2][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[2][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[2][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[2][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[2][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[2][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[2][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[6912]; - idxBn = lut_posBnInCnProcBuf_CNG4[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[3][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[3][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[3][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[3][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[3][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG4[3][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG4[3][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[8832]; - idxBn = lut_posBnInCnProcBuf_CNG5[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][7]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][8]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][8]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][9]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][9]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][10]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][10]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][11]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][11]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][12]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][12]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][13]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][13]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][14]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][14]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][15]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][15]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][16]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][16]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[0][17]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[0][17]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[15744]; - idxBn = lut_posBnInCnProcBuf_CNG5[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][7]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][8]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][8]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][9]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][9]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][10]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][10]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][11]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][11]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][12]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][12]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][13]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][13]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][14]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][14]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][15]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][15]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][16]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][16]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[1][17]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[1][17]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[22656]; - idxBn = lut_posBnInCnProcBuf_CNG5[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][7]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][8]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][8]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][9]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][9]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][10]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][10]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][11]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][11]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][12]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][12]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][13]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][13]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][14]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][14]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][15]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][15]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][16]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][16]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[2][17]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[2][17]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[29568]; - idxBn = lut_posBnInCnProcBuf_CNG5[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][7]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][8]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][8]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][9]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][9]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][10]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][10]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][11]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][11]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][12]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][12]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][13]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][13]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][14]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][14]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][15]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][15]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][16]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][16]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[3][17]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[3][17]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[36480]; - idxBn = lut_posBnInCnProcBuf_CNG5[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][7]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][8]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][8]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][9]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][9]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][10]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][10]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][11]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][11]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][12]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][12]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][13]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][13]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][14]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][14]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][15]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][15]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][16]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][16]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG5[4][17]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG5[4][17]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[43392]; - idxBn = lut_posBnInCnProcBuf_CNG6[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[0][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[0][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[46464]; - idxBn = lut_posBnInCnProcBuf_CNG6[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[1][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[1][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[49536]; - idxBn = lut_posBnInCnProcBuf_CNG6[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[2][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[2][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[52608]; - idxBn = lut_posBnInCnProcBuf_CNG6[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[3][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[3][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[55680]; - idxBn = lut_posBnInCnProcBuf_CNG6[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[4][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[4][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[58752]; - idxBn = lut_posBnInCnProcBuf_CNG6[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][4]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][5]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][5]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][6]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][6]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG6[5][7]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG6[5][7]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[61824]; - idxBn = lut_posBnInCnProcBuf_CNG7[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[0][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[0][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[0][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[0][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[0][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[0][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[0][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[63744]; - idxBn = lut_posBnInCnProcBuf_CNG7[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[1][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[1][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[1][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[1][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[1][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[1][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[1][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[65664]; - idxBn = lut_posBnInCnProcBuf_CNG7[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[2][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[2][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[2][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[2][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[2][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[2][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[2][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[67584]; - idxBn = lut_posBnInCnProcBuf_CNG7[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[3][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[3][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[3][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[3][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[3][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[3][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[3][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[69504]; - idxBn = lut_posBnInCnProcBuf_CNG7[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[4][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[4][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[4][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[4][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[4][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[4][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[4][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[71424]; - idxBn = lut_posBnInCnProcBuf_CNG7[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[5][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[5][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[5][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[5][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[5][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[5][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[5][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[5][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[5][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[73344]; - idxBn = lut_posBnInCnProcBuf_CNG7[6][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[6][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[6][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[6][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[6][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[6][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[6][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[6][3]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG7[6][4]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG7[6][4]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[75264]; - idxBn = lut_posBnInCnProcBuf_CNG8[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[0][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[76032]; - idxBn = lut_posBnInCnProcBuf_CNG8[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[1][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[76800]; - idxBn = lut_posBnInCnProcBuf_CNG8[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[2][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[77568]; - idxBn = lut_posBnInCnProcBuf_CNG8[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[3][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[78336]; - idxBn = lut_posBnInCnProcBuf_CNG8[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[4][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[79104]; - idxBn = lut_posBnInCnProcBuf_CNG8[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[5][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[5][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[5][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[79872]; - idxBn = lut_posBnInCnProcBuf_CNG8[6][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[6][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[6][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[6][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[80640]; - idxBn = lut_posBnInCnProcBuf_CNG8[7][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[7][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG8[7][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG8[7][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[81408]; - idxBn = lut_posBnInCnProcBuf_CNG9[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[0][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[82176]; - idxBn = lut_posBnInCnProcBuf_CNG9[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[1][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[82944]; - idxBn = lut_posBnInCnProcBuf_CNG9[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[2][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[83712]; - idxBn = lut_posBnInCnProcBuf_CNG9[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[3][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[84480]; - idxBn = lut_posBnInCnProcBuf_CNG9[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[4][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[85248]; - idxBn = lut_posBnInCnProcBuf_CNG9[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[5][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[5][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[5][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[86016]; - idxBn = lut_posBnInCnProcBuf_CNG9[6][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[6][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[6][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[6][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[86784]; - idxBn = lut_posBnInCnProcBuf_CNG9[7][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[7][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[7][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[7][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[87552]; - idxBn = lut_posBnInCnProcBuf_CNG9[8][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[8][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG9[8][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG9[8][1]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[88320]; - idxBn = lut_posBnInCnProcBuf_CNG10[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[0][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[88704]; - idxBn = lut_posBnInCnProcBuf_CNG10[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[1][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[89088]; - idxBn = lut_posBnInCnProcBuf_CNG10[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[2][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[89472]; - idxBn = lut_posBnInCnProcBuf_CNG10[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[3][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[89856]; - idxBn = lut_posBnInCnProcBuf_CNG10[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[4][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[90240]; - idxBn = lut_posBnInCnProcBuf_CNG10[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[5][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[90624]; - idxBn = lut_posBnInCnProcBuf_CNG10[6][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[6][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[91008]; - idxBn = lut_posBnInCnProcBuf_CNG10[7][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[7][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[91392]; - idxBn = lut_posBnInCnProcBuf_CNG10[8][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[8][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[91776]; - idxBn = lut_posBnInCnProcBuf_CNG10[9][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG10[9][0]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[92160]; - idxBn = lut_posBnInCnProcBuf_CNG19[0][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[0][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[0][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[0][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[0][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[0][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[0][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[0][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[93696]; - idxBn = lut_posBnInCnProcBuf_CNG19[1][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[1][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[1][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[1][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[1][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[1][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[1][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[1][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[95232]; - idxBn = lut_posBnInCnProcBuf_CNG19[2][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[2][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[2][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[2][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[2][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[2][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[2][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[2][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[96768]; - idxBn = lut_posBnInCnProcBuf_CNG19[3][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[3][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[3][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[3][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[3][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[3][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[3][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[3][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[98304]; - idxBn = lut_posBnInCnProcBuf_CNG19[4][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[4][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[4][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[4][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[4][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[4][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[4][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[4][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[99840]; - idxBn = lut_posBnInCnProcBuf_CNG19[5][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[5][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[5][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[5][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[5][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[5][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[5][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[5][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[101376]; - idxBn = lut_posBnInCnProcBuf_CNG19[6][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[6][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[6][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[6][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[6][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[6][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[6][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[6][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[102912]; - idxBn = lut_posBnInCnProcBuf_CNG19[7][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[7][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[7][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[7][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[7][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[7][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[7][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[7][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[104448]; - idxBn = lut_posBnInCnProcBuf_CNG19[8][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[8][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[8][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[8][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[8][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[8][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[8][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[8][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[105984]; - idxBn = lut_posBnInCnProcBuf_CNG19[9][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[9][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[9][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[9][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[9][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[9][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[9][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[9][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[107520]; - idxBn = lut_posBnInCnProcBuf_CNG19[10][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[10][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[10][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[10][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[10][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[10][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[10][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[10][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[109056]; - idxBn = lut_posBnInCnProcBuf_CNG19[11][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[11][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[11][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[11][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[11][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[11][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[11][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[11][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[110592]; - idxBn = lut_posBnInCnProcBuf_CNG19[12][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[12][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[12][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[12][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[12][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[12][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[12][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[12][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[112128]; - idxBn = lut_posBnInCnProcBuf_CNG19[13][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[13][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[13][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[13][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[13][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[13][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[13][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[13][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[113664]; - idxBn = lut_posBnInCnProcBuf_CNG19[14][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[14][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[14][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[14][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[14][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[14][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[14][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[14][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[115200]; - idxBn = lut_posBnInCnProcBuf_CNG19[15][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[15][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[15][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[15][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[15][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[15][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[15][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[15][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[116736]; - idxBn = lut_posBnInCnProcBuf_CNG19[16][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[16][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[16][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[16][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[16][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[16][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[16][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[16][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[118272]; - idxBn = lut_posBnInCnProcBuf_CNG19[17][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[17][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[17][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[17][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[17][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[17][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[17][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[17][3]); - p_cnProcBuf += Z; - p_cnProcBuf= &cnProcBuf[119808]; - idxBn = lut_posBnInCnProcBuf_CNG19[18][0]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[18][0]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[18][1]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[18][1]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[18][2]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[18][2]); - p_cnProcBuf += Z; - idxBn = lut_posBnInCnProcBuf_CNG19[18][3]*Z; - nrLDPC_circ_memcpy1(p_cnProcBuf, &llr[idxBn], Z, lut_circShift_CNG19[18][3]); - p_cnProcBuf += Z; -}