BG1 included

There is not much gain in BLER performance vs computational complexity of BG1 compared to the flooding decoder. I decide to stop the work for now. I might try to bring down the complexity in future.

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -86,6 +86,7 @@ typedef struct {
   double snr[400];
   double ber[400];
   double bler[400];
+  double decoding_time[400];
 } n_iter_stats_t;
 
 nrLDPC_encoderfunc_t encoder_orig;
@@ -107,7 +108,8 @@ int test_ldpc(short max_iterations,
               time_stats_t *time_optim,
               time_stats_t *time_decoder,
               n_iter_stats_t *dec_iter,
-              int nsnr)
+              int nsnr,
+              int decMode)
 {
   //clock initiate
   //time_stats_t time,time_optim,tinput,tprep,tparity,toutput, time_decoder;
@@ -270,6 +272,16 @@ int test_ldpc(short max_iterations,
   removed_bit=(nrows-no_punctured_columns-2) * Zc+block_length-(int)(block_length/((float)nom_rate/(float)denom_rate));
   encoder_implemparams_t impp=INIT0_LDPCIMPLEMPARAMS;
 
+/*  // CRC attachement
+  for (j=0; j<n_segments; j++) {
+    int crc = 0;
+    crc = crc24b(test_input[j],block_length-24)>>8;
+    test_input[j][(block_length-24)>>3] = ((uint8_t*)&crc)[2];
+    test_input[j][1+((block_length-24)>>3)] = ((uint8_t*)&crc)[1];
+    test_input[j][2+((block_length-24)>>3)] = ((uint8_t*)&crc)[0];
+  }
+*/
+ 
   impp.gen_code=1;
   if (ntrials==0)
     encoder_orig(test_input,channel_input, Zc, BG, block_length, BG, &impp);
@@ -359,6 +371,7 @@ int test_ldpc(short max_iterations,
         decParams[j].numMaxIter=max_iterations;
         decParams[j].outMode = nrLDPC_outMode_BIT;
         decParams[j].block_length=block_length;
+        decParams[j].decMode=decMode;
         nrLDPC_initcall(&decParams[j], (int8_t*)channel_output_fixed[j], (int8_t*)estimated_output[j]);
       }
       for(int j=0;j<n_segments;j++) {
@@ -455,8 +468,9 @@ int main(int argc, char *argv[])
   n_iter_stats_t dec_iter;
 
   short BG=0,Zc,Kb=0;
+  int decMode = nrLDPC_decMode_flooding;
 
-  while ((c = getopt (argc, argv, "q:r:s:S:l:G:n:d:i:t:u:hv:")) != -1)
+  while ((c = getopt (argc, argv, "q:r:s:S:l:G:m:n:d:i:t:u:hv:")) != -1)
     switch (c)
     {
       case 'q':
@@ -483,6 +497,10 @@ int main(int argc, char *argv[])
         n_trials = atoi(optarg);
         break;
 
+      case 'm':
+        decMode = atoi(optarg);
+        break;
+
       case 's':
         SNR0 = atof(optarg);
         break;
@@ -610,7 +628,8 @@ int main(int argc, char *argv[])
                                 time_optim,
                                 time_decoder,
                                 &dec_iter,
-                                i);
+                                i,
+                                decMode);
 
     dec_iter.snr[i] = SNR;
     dec_iter.ber[i] = (float)errors_bit/(float)n_trials/(float)block_length/(double)n_segments;
@@ -626,6 +645,7 @@ int main(int argc, char *argv[])
     printf("Encoding time std: %15.3f us\n",sqrt((double)time_optim->diff_square/time_optim->trials/pow(1000,2)/pow(get_cpu_freq_GHz(),2)-pow((double)time_optim->diff/time_optim->trials/1000.0/get_cpu_freq_GHz(),2)));
     printf("Encoding time max: %15.3f us\n",(double)time_optim->max/1000.0/get_cpu_freq_GHz());
     printf("\n");
+    dec_iter.decoding_time[i] = (double)time_decoder->diff/time_decoder->trials/1000.0/get_cpu_freq_GHz();
     printf("Decoding time mean: %15.3f us\n",(double)time_decoder->diff/time_decoder->trials/1000.0/get_cpu_freq_GHz());
     printf("Decoding time std: %15.3f us\n",sqrt((double)time_decoder->diff_square/time_decoder->trials/pow(1000,2)/pow(get_cpu_freq_GHz(),2)-pow((double)time_decoder->diff/time_decoder->trials/1000.0/get_cpu_freq_GHz(),2)));
     printf("Decoding time max: %15.3f us\n",(double)time_decoder->max/1000.0/get_cpu_freq_GHz());
@@ -655,6 +675,7 @@ int main(int argc, char *argv[])
   LOG_MM("ldpctestStats.m","BLER",&dec_iter.bler[0],i,1,7);
   LOG_MM("ldpctestStats.m","BER",&dec_iter.ber[0],i,1,7);
   LOG_MM("ldpctestStats.m","meanIter",&dec_iter.n_iter_mean[0],i,1,7);
+  LOG_MM("ldpctestStats.m","decTime",&dec_iter.decoding_time[0],i,1,7);
 
   loader_reset();
   logTerm();

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c

@@ -39,16 +39,19 @@
 #include "nrLDPC_bnProc.h"
 
 #define NR_LDPC_ENABLE_PARITY_CHECK
-//#define NR_LDPC_PROFILER_DETAIL
+//#define NR_LDPC_DEBUG_MODE
+#define NR_LDPC_PROFILER_DETAIL
 
 #ifdef NR_LDPC_DEBUG_MODE
 #include "nrLDPC_tools/nrLDPC_debug.h"
 #endif
 
+static inline uint32_t nrLDPC_decoder_core_layer(int8_t* p_llr, int8_t* p_out, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler);
 static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler);
 int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type);
 void nrLDPC_initcall(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_out) {
 }
+
 int32_t nrLDPC_decod(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_out, t_nrLDPC_time_stats* p_profiler)
 {
     uint32_t numLLR;
@@ -60,11 +63,139 @@ int32_t nrLDPC_decod(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_
     numLLR = nrLDPC_init(p_decParams, p_lut);
 
     // Launch LDPC decoder core for one segment
-    numIter = nrLDPC_decoder_core(p_llr, p_out, numLLR, p_lut, p_decParams, p_profiler);
+    if (p_decParams->decMode == nrLDPC_decMode_layerCNG)
+      numIter = nrLDPC_decoder_core_layer(p_llr, p_out, numLLR, p_lut, p_decParams, p_profiler);
+    else
+      numIter = nrLDPC_decoder_core(p_llr, p_out, numLLR, p_lut, p_decParams, p_profiler);
 
     return numIter;
 }
 
+static inline uint32_t nrLDPC_decoder_core_layer(int8_t* p_llr, int8_t* p_out, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler)
+{
+  uint16_t Z          = p_decParams->Z;
+  uint8_t  BG         = p_decParams->BG;
+  uint8_t  numMaxIter = p_decParams->numMaxIter;
+  e_nrLDPC_outMode outMode = p_decParams->outMode;
+
+  int8_t cnProcBuf[NR_LDPC_SIZE_CN_PROC_BUF]    __attribute__ ((aligned(32))) = {0};
+  int8_t cnProcBufPc[NR_LDPC_SIZE_CN_PROC_BUF]  __attribute__ ((aligned(32))) = {0};
+  int8_t cnProcBufRes[NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32))) = {0};
+  int8_t bnProcBuf[NR_LDPC_SIZE_BN_PROC_BUF]    __attribute__ ((aligned(32))) = {0};
+  int8_t bnProcBufRes[NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32))) = {0};
+  int8_t llrRes[NR_LDPC_MAX_NUM_LLR]            __attribute__ ((aligned(32))) = {0};
+  int8_t llrProcBuf[NR_LDPC_MAX_NUM_LLR]        __attribute__ ((aligned(32))) = {0};
+  int8_t llrOut[NR_LDPC_MAX_NUM_LLR]            __attribute__ ((aligned(32))) = {0};
+  // Minimum number of iterations is 1
+  // 0 iterations means hard-decision on input LLRs
+  uint32_t i = 0;
+  // Initialize with parity check fail != 0
+  int32_t pcRes = 1;
+  int8_t* p_llrOut;
+
+  if (outMode == nrLDPC_outMode_LLRINT8)
+  {
+    p_llrOut = p_out;
+  }
+  else
+  {
+    // Use LLR processing buffer as temporary output buffer
+    p_llrOut = llrOut;
+  }
+
+  // Initialization
+#ifdef NR_LDPC_PROFILER_DETAIL
+  start_meas(&p_profiler->llr2llrProcBuf);
+#endif
+  nrLDPC_llr2llrProcBuf(p_lut, p_llr, llrProcBuf, Z, BG);
+  nrLDPC_bnProcPc(p_lut, bnProcBuf, bnProcBufRes, llrProcBuf, llrRes, Z);
+  nrLDPC_bnProc(p_lut, bnProcBuf, bnProcBufRes, llrRes, Z);
+#ifdef NR_LDPC_PROFILER_DETAIL
+  stop_meas(&p_profiler->llr2llrProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+  nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_PROC);
+  nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_llr);
+#endif
+
+  while ( (i < numMaxIter) && (pcRes != 0) )
+  {
+
+    // CN processing
+    if (BG == 1)
+      nrLDPC_layerProc_BG1(p_lut, p_llr, llrProcBuf, llrRes, cnProcBuf, cnProcBufRes, bnProcBuf, bnProcBufRes, Z, p_profiler);
+    else
+      nrLDPC_layerProc_BG2(p_lut, p_llr, llrProcBuf, llrRes, cnProcBuf, cnProcBufRes, bnProcBuf, bnProcBufRes, Z, p_profiler);
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, cnProcBufRes);
+#endif
+
+    // Parity Check
+#ifdef NR_LDPC_ENABLE_PARITY_CHECK
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->cnProcPc);
+#endif
+    if (BG == 1) {
+      nrLDPC_bn2cnProcBuf_BG1(p_lut, bnProcBufRes, cnProcBufPc, Z);
+      pcRes = nrLDPC_cnProcPc_BG1(p_lut, cnProcBufPc, cnProcBufRes, Z);
+    }
+    else {
+      nrLDPC_bn2cnProcBuf_BG2(p_lut, bnProcBufRes, cnProcBufPc, Z);
+      pcRes = nrLDPC_cnProcPc_BG2(p_lut, cnProcBufPc, cnProcBufRes, Z);
+    }
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->cnProcPc);
+#endif
+#endif
+    nrLDPC_llrRes2llrOut(p_lut, p_llrOut, llrRes, Z, BG);
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_llrOut);
+#endif
+    // Increase iteration counter
+    i++;
+  }
+
+  // If maximum number of iterations reached an PC still fails increase number of iterations
+  // Thus, i > numMaxIter indicates that PC has failed
+
+#ifdef NR_LDPC_ENABLE_PARITY_CHECK
+  if (pcRes != 0)
+  {
+    i++;
+  }
+#endif
+
+  // Assign results from processing buffer to output
+#ifdef NR_LDPC_PROFILER_DETAIL
+  start_meas(&p_profiler->llrRes2llrOut);
+#endif
+  nrLDPC_llrRes2llrOut(p_lut, p_llrOut, llrRes, Z, BG);
+#ifdef NR_LDPC_PROFILER_DETAIL
+  stop_meas(&p_profiler->llrRes2llrOut);
+#endif
+
+  // Hard-decision
+#ifdef NR_LDPC_PROFILER_DETAIL
+  start_meas(&p_profiler->llr2bit);
+#endif
+  if (outMode == nrLDPC_outMode_BIT)
+  {
+    nrLDPC_llr2bitPacked(p_out, p_llrOut, numLLR);
+  }
+  else if (outMode == nrLDPC_outMode_BITINT8)
+  {
+    nrLDPC_llr2bit(p_out, p_llrOut, numLLR);
+  }
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+  stop_meas(&p_profiler->llr2bit);
+#endif
+
+  return i;
+}
+
 /**
    \brief Performs LDPC decoding of one code block
    \param p_llr Input LLRs
@@ -105,7 +236,6 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_
         p_llrOut = llrOut;
     }
 
-
     // Initialization
 #ifdef NR_LDPC_PROFILER_DETAIL
     start_meas(&p_profiler->llr2llrProcBuf);
@@ -117,7 +247,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_
 
 #ifdef NR_LDPC_DEBUG_MODE
     nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_PROC);
-    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, llrProcBuf);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_llr);
 #endif
 
 #ifdef NR_LDPC_PROFILER_DETAIL
@@ -229,6 +359,10 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_
 #ifdef NR_LDPC_DEBUG_MODE
     nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, cnProcBuf);
 #endif
+    nrLDPC_llrRes2llrOut(p_lut, p_llrOut, llrRes, Z, BG);
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_llrOut);
+#endif
 
     // Parity Check not necessary here since it will fail
     // because first 2 cols/BNs in BG are punctured and cannot be
@@ -342,6 +476,10 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_
 #ifdef NR_LDPC_PROFILER_DETAIL
         stop_meas(&p_profiler->cnProcPc);
 #endif
+#endif
+        nrLDPC_llrRes2llrOut(p_lut, p_llrOut, llrRes, Z, BG);
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_llrOut);
 #endif
     }
 

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init.h

@@ -94,6 +94,96 @@ static inline uint32_t nrLDPC_init(t_nrLDPC_dec_params* p_decParams, t_nrLDPC_lu
             p_lut->startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R15;
 
             numLLR = NR_LDPC_NCOL_BG2_R15*Z;
+
+            p_lut->numSG[0] = &numSG_BG2_CNG3_R15;
+            p_lut->numSG[1] = &numSG_BG2_CNG4_R15;
+            p_lut->numSG[2] = &numSG_BG2_CNG5_R15;
+            p_lut->numSG[3] = &numSG_BG2_CNG6_R15;
+            p_lut->numSG[4] = &numSG_BG2_CNG8_R15;
+            p_lut->numSG[5] = &numSG_BG2_CNG10_R15;
+            p_lut->numSG[6] = 0;
+            p_lut->numSG[7] = 0;
+            p_lut->numSG[8] = 0;
+
+            p_lut->maxBnInSG[0] = &maxBnInSG_CNG3_R15;
+            p_lut->maxBnInSG[1] = &maxBnInSG_CNG4_R15;
+            p_lut->maxBnInSG[2] = &maxBnInSG_CNG5_R15;
+            p_lut->maxBnInSG[3] = &maxBnInSG_CNG6_R15;
+            p_lut->maxBnInSG[4] = &maxBnInSG_CNG8_R15;
+            p_lut->maxBnInSG[5] = &maxBnInSG_CNG10_R15;
+            p_lut->maxBnInSG[6] = 0;
+            p_lut->maxBnInSG[7] = 0;
+            p_lut->maxBnInSG[8] = 0;
+
+            p_lut->listSG[0] = (const uint16_t*) listSG_BG2_CNG3_R15;
+            p_lut->listSG[1] = (const uint16_t*) listSG_BG2_CNG4_R15;
+            p_lut->listSG[2] = (const uint16_t*) listSG_BG2_CNG5_R15;
+            p_lut->listSG[3] = (const uint16_t*) listSG_BG2_CNG6_R15;
+            p_lut->listSG[4] = (const uint16_t*) listSG_BG2_CNG8_R15;
+            p_lut->listSG[5] = (const uint16_t*) listSG_BG2_CNG10_R15;
+            p_lut->listSG[6] = NULL;
+            p_lut->listSG[7] = NULL;
+            p_lut->listSG[8] = NULL;
+
+            p_lut->numBnInSG[0] = (const uint16_t*) numBNinSG_BG2_CNG3_R15;
+            p_lut->numBnInSG[1] = (const uint16_t*) numBNinSG_BG2_CNG4_R15;
+            p_lut->numBnInSG[2] = (const uint16_t*) numBNinSG_BG2_CNG5_R15;
+            p_lut->numBnInSG[3] = (const uint16_t*) numBNinSG_BG2_CNG6_R15;
+            p_lut->numBnInSG[4] = (const uint16_t*) numBNinSG_BG2_CNG8_R15;
+            p_lut->numBnInSG[5] = (const uint16_t*) numBNinSG_BG2_CNG10_R15;
+            p_lut->numBnInSG[6] = NULL;
+            p_lut->numBnInSG[7] = NULL;
+            p_lut->numBnInSG[8] = NULL;
+
+            p_lut->bnPosSG[0] = (const uint16_t**) bnIdx_BG2_CNG3_SG_R15;
+            p_lut->bnPosSG[1] = (const uint16_t**) bnIdx_BG2_CNG4_SG_R15;
+            p_lut->bnPosSG[2] = (const uint16_t**) bnIdx_BG2_CNG5_SG_R15;
+            p_lut->bnPosSG[3] = (const uint16_t**) bnIdx_BG2_CNG6_SG_R15;
+            p_lut->bnPosSG[4] = (const uint16_t**) bnIdx_BG2_CNG8_SG_R15;
+            p_lut->bnPosSG[5] = (const uint16_t**) bnIdx_BG2_CNG10_SG_R15;
+            p_lut->bnPosSG[6] = NULL;
+            p_lut->bnPosSG[7] = NULL;
+            p_lut->bnPosSG[8] = NULL;
+
+            p_lut->idxBnInSG_cnProcBuf[0] = (const uint16_t**) idxBnProcBuf_BG2_CNG3_R15;
+            p_lut->idxBnInSG_cnProcBuf[1] = (const uint16_t**) idxBnProcBuf_BG2_CNG4_R15;
+            p_lut->idxBnInSG_cnProcBuf[2] = (const uint16_t**) idxBnProcBuf_BG2_CNG5_R15;
+            p_lut->idxBnInSG_cnProcBuf[3] = (const uint16_t**) idxBnProcBuf_BG2_CNG6_R15;
+            p_lut->idxBnInSG_cnProcBuf[4] = (const uint16_t**) idxBnProcBuf_BG2_CNG8_R15;
+            p_lut->idxBnInSG_cnProcBuf[5] = (const uint16_t**) idxBnProcBuf_BG2_CNG10_R15;
+            p_lut->idxBnInSG_cnProcBuf[6] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[7] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[8] = NULL;
+
+            p_lut->startAddrSG_cnProcBuf[0] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG3_R15;
+            p_lut->startAddrSG_cnProcBuf[1] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG4_R15;
+            p_lut->startAddrSG_cnProcBuf[2] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG5_R15;
+            p_lut->startAddrSG_cnProcBuf[3] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG6_R15;
+            p_lut->startAddrSG_cnProcBuf[4] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG8_R15;
+            p_lut->startAddrSG_cnProcBuf[5] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG10_R15;
+            p_lut->startAddrSG_cnProcBuf[6] = NULL;
+            p_lut->startAddrSG_cnProcBuf[7] = NULL;
+            p_lut->startAddrSG_cnProcBuf[8] = NULL;
+
+            p_lut->listStartAddrSG[0] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG3_R15;
+            p_lut->listStartAddrSG[1] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG4_R15;
+            p_lut->listStartAddrSG[2] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG5_R15;
+            p_lut->listStartAddrSG[3] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG6_R15;
+            p_lut->listStartAddrSG[4] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG8_R15;
+            p_lut->listStartAddrSG[5] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG10_R15;
+            p_lut->listStartAddrSG[6] = NULL;
+            p_lut->listStartAddrSG[7] = NULL;
+            p_lut->listStartAddrSG[8] = NULL;
+
+            p_lut->startAddrLlrSG[0] = (const uint16_t*) startAddrLlrSG_BG2_CNG3_R15;
+            p_lut->startAddrLlrSG[1] = (const uint16_t*) startAddrLlrSG_BG2_CNG4_R15;
+            p_lut->startAddrLlrSG[2] = (const uint16_t*) startAddrLlrSG_BG2_CNG5_R15;
+            p_lut->startAddrLlrSG[3] = (const uint16_t*) startAddrLlrSG_BG2_CNG6_R15;
+            p_lut->startAddrLlrSG[4] = (const uint16_t*) startAddrLlrSG_BG2_CNG8_R15;
+            p_lut->startAddrLlrSG[5] = (const uint16_t*) startAddrLlrSG_BG2_CNG10_R15;
+            p_lut->startAddrLlrSG[6] = NULL;
+            p_lut->startAddrLlrSG[7] = NULL;
+            p_lut->startAddrLlrSG[8] = NULL;
         }
         else if (R == 13)
         {
@@ -126,6 +216,96 @@ static inline uint32_t nrLDPC_init(t_nrLDPC_dec_params* p_decParams, t_nrLDPC_lu
             p_lut->startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R13;
 
             numLLR = NR_LDPC_NCOL_BG2_R13*Z;
+
+            p_lut->numSG[0] = 0;
+            p_lut->numSG[1] = &numSG_BG2_CNG4_R13;
+            p_lut->numSG[2] = &numSG_BG2_CNG5_R13;
+            p_lut->numSG[3] = &numSG_BG2_CNG6_R13;
+            p_lut->numSG[4] = &numSG_BG2_CNG8_R13;
+            p_lut->numSG[5] = &numSG_BG2_CNG10_R13;
+            p_lut->numSG[6] = 0;
+            p_lut->numSG[7] = 0;
+            p_lut->numSG[8] = 0;
+
+            p_lut->maxBnInSG[0] = 0;
+            p_lut->maxBnInSG[1] = &maxBnInSG_CNG4_R13;
+            p_lut->maxBnInSG[2] = &maxBnInSG_CNG5_R13;
+            p_lut->maxBnInSG[3] = &maxBnInSG_CNG6_R13;
+            p_lut->maxBnInSG[4] = &maxBnInSG_CNG8_R13;
+            p_lut->maxBnInSG[5] = &maxBnInSG_CNG10_R13;
+            p_lut->maxBnInSG[6] = 0;
+            p_lut->maxBnInSG[7] = 0;
+            p_lut->maxBnInSG[8] = 0;
+
+            p_lut->listSG[0] = NULL;
+            p_lut->listSG[1] = (const uint16_t*) listSG_BG2_CNG4_R13;
+            p_lut->listSG[2] = (const uint16_t*) listSG_BG2_CNG5_R13;
+            p_lut->listSG[3] = (const uint16_t*) listSG_BG2_CNG6_R13;
+            p_lut->listSG[4] = (const uint16_t*) listSG_BG2_CNG8_R13;
+            p_lut->listSG[5] = (const uint16_t*) listSG_BG2_CNG10_R13;
+            p_lut->listSG[6] = NULL;
+            p_lut->listSG[7] = NULL;
+            p_lut->listSG[8] = NULL;
+
+            p_lut->numBnInSG[0] = NULL;
+            p_lut->numBnInSG[1] = (const uint16_t*) numBNinSG_BG2_CNG4_R13;
+            p_lut->numBnInSG[2] = (const uint16_t*) numBNinSG_BG2_CNG5_R13;
+            p_lut->numBnInSG[3] = (const uint16_t*) numBNinSG_BG2_CNG6_R13;
+            p_lut->numBnInSG[4] = (const uint16_t*) numBNinSG_BG2_CNG8_R13;
+            p_lut->numBnInSG[5] = (const uint16_t*) numBNinSG_BG2_CNG10_R13;
+            p_lut->numBnInSG[6] = NULL;
+            p_lut->numBnInSG[7] = NULL;
+            p_lut->numBnInSG[8] = NULL;
+
+            p_lut->bnPosSG[0] = NULL;
+            p_lut->bnPosSG[1] = (const uint16_t**) bnIdx_BG2_CNG4_SG_R13;
+            p_lut->bnPosSG[2] = (const uint16_t**) bnIdx_BG2_CNG5_SG_R13;
+            p_lut->bnPosSG[3] = (const uint16_t**) bnIdx_BG2_CNG6_SG_R13;
+            p_lut->bnPosSG[4] = (const uint16_t**) bnIdx_BG2_CNG8_SG_R13;
+            p_lut->bnPosSG[5] = (const uint16_t**) bnIdx_BG2_CNG10_SG_R13;
+            p_lut->bnPosSG[6] = NULL;
+            p_lut->bnPosSG[7] = NULL;
+            p_lut->bnPosSG[8] = NULL;
+
+            p_lut->idxBnInSG_cnProcBuf[0] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[1] = (const uint16_t**) idxBnProcBuf_BG2_CNG4_R13;
+            p_lut->idxBnInSG_cnProcBuf[2] = (const uint16_t**) idxBnProcBuf_BG2_CNG5_R13;
+            p_lut->idxBnInSG_cnProcBuf[3] = (const uint16_t**) idxBnProcBuf_BG2_CNG6_R13;
+            p_lut->idxBnInSG_cnProcBuf[4] = (const uint16_t**) idxBnProcBuf_BG2_CNG8_R13;
+            p_lut->idxBnInSG_cnProcBuf[5] = (const uint16_t**) idxBnProcBuf_BG2_CNG10_R13;
+            p_lut->idxBnInSG_cnProcBuf[6] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[7] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[8] = NULL;
+
+            p_lut->startAddrSG_cnProcBuf[0] = NULL;
+            p_lut->startAddrSG_cnProcBuf[1] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG4_R13;
+            p_lut->startAddrSG_cnProcBuf[2] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG5_R13;
+            p_lut->startAddrSG_cnProcBuf[3] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG6_R13;
+            p_lut->startAddrSG_cnProcBuf[4] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG8_R13;
+            p_lut->startAddrSG_cnProcBuf[5] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG10_R13;
+            p_lut->startAddrSG_cnProcBuf[6] = NULL;
+            p_lut->startAddrSG_cnProcBuf[7] = NULL;
+            p_lut->startAddrSG_cnProcBuf[8] = NULL;
+
+            p_lut->listStartAddrSG[0] = NULL;
+            p_lut->listStartAddrSG[1] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG4_R13;
+            p_lut->listStartAddrSG[2] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG5_R13;
+            p_lut->listStartAddrSG[3] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG6_R13;
+            p_lut->listStartAddrSG[4] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG8_R13;
+            p_lut->listStartAddrSG[5] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG10_R13;
+            p_lut->listStartAddrSG[6] = NULL;
+            p_lut->listStartAddrSG[7] = NULL;
+            p_lut->listStartAddrSG[8] = NULL;
+
+            p_lut->startAddrLlrSG[0] = NULL;
+            p_lut->startAddrLlrSG[1] = (const uint16_t*) startAddrLlrSG_BG2_CNG4_R13;
+            p_lut->startAddrLlrSG[2] = (const uint16_t*) startAddrLlrSG_BG2_CNG5_R13;
+            p_lut->startAddrLlrSG[3] = (const uint16_t*) startAddrLlrSG_BG2_CNG6_R13;
+            p_lut->startAddrLlrSG[4] = (const uint16_t*) startAddrLlrSG_BG2_CNG8_R13;
+            p_lut->startAddrLlrSG[5] = (const uint16_t*) startAddrLlrSG_BG2_CNG10_R13;
+            p_lut->startAddrLlrSG[6] = NULL;
+            p_lut->startAddrLlrSG[7] = NULL;
+            p_lut->startAddrLlrSG[8] = NULL;
         }
         else if (R == 23)
         {
@@ -158,6 +338,96 @@ static inline uint32_t nrLDPC_init(t_nrLDPC_dec_params* p_decParams, t_nrLDPC_lu
             p_lut->startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R23;
 
             numLLR = NR_LDPC_NCOL_BG2_R23*Z;
+
+            p_lut->numSG[0] = 0;
+            p_lut->numSG[1] = &numSG_BG2_CNG4_R23;
+            p_lut->numSG[2] = 0;
+            p_lut->numSG[3] = &numSG_BG2_CNG6_R23;
+            p_lut->numSG[4] = &numSG_BG2_CNG8_R23;
+            p_lut->numSG[5] = &numSG_BG2_CNG10_R23;
+            p_lut->numSG[6] = 0;
+            p_lut->numSG[7] = 0;
+            p_lut->numSG[8] = 0;
+
+            p_lut->maxBnInSG[0] = 0;
+            p_lut->maxBnInSG[1] = &maxBnInSG_CNG4_R23;
+            p_lut->maxBnInSG[2] = 0;
+            p_lut->maxBnInSG[3] = &maxBnInSG_CNG6_R23;
+            p_lut->maxBnInSG[4] = &maxBnInSG_CNG8_R23;
+            p_lut->maxBnInSG[5] = &maxBnInSG_CNG10_R23;
+            p_lut->maxBnInSG[6] = 0;
+            p_lut->maxBnInSG[7] = 0;
+            p_lut->maxBnInSG[8] = 0;
+
+            p_lut->listSG[0] = NULL;
+            p_lut->listSG[1] = (const uint16_t*) listSG_BG2_CNG4_R23;
+            p_lut->listSG[2] = NULL;
+            p_lut->listSG[3] = (const uint16_t*) listSG_BG2_CNG6_R23;
+            p_lut->listSG[4] = (const uint16_t*) listSG_BG2_CNG8_R23;
+            p_lut->listSG[5] = (const uint16_t*) listSG_BG2_CNG10_R23;
+            p_lut->listSG[6] = NULL;
+            p_lut->listSG[7] = NULL;
+            p_lut->listSG[8] = NULL;
+
+            p_lut->numBnInSG[0] = NULL;
+            p_lut->numBnInSG[1] = (const uint16_t*) numBNinSG_BG2_CNG4_R23;
+            p_lut->numBnInSG[2] = NULL;
+            p_lut->numBnInSG[3] = (const uint16_t*) numBNinSG_BG2_CNG6_R23;
+            p_lut->numBnInSG[4] = (const uint16_t*) numBNinSG_BG2_CNG8_R23;
+            p_lut->numBnInSG[5] = (const uint16_t*) numBNinSG_BG2_CNG10_R23;
+            p_lut->numBnInSG[6] = NULL;
+            p_lut->numBnInSG[7] = NULL;
+            p_lut->numBnInSG[8] = NULL;
+
+            p_lut->bnPosSG[0] = NULL;
+            p_lut->bnPosSG[1] = (const uint16_t**) bnIdx_BG2_CNG4_SG_R23;
+            p_lut->bnPosSG[2] = NULL;
+            p_lut->bnPosSG[3] = (const uint16_t**) bnIdx_BG2_CNG6_SG_R23;
+            p_lut->bnPosSG[4] = (const uint16_t**) bnIdx_BG2_CNG8_SG_R23;
+            p_lut->bnPosSG[5] = (const uint16_t**) bnIdx_BG2_CNG10_SG_R23;
+            p_lut->bnPosSG[6] = NULL;
+            p_lut->bnPosSG[7] = NULL;
+            p_lut->bnPosSG[8] = NULL;
+
+            p_lut->idxBnInSG_cnProcBuf[0] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[1] = (const uint16_t**) idxBnProcBuf_BG2_CNG4_R23;
+            p_lut->idxBnInSG_cnProcBuf[2] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[3] = (const uint16_t**) idxBnProcBuf_BG2_CNG6_R23;
+            p_lut->idxBnInSG_cnProcBuf[4] = (const uint16_t**) idxBnProcBuf_BG2_CNG8_R23;
+            p_lut->idxBnInSG_cnProcBuf[5] = (const uint16_t**) idxBnProcBuf_BG2_CNG10_R23;
+            p_lut->idxBnInSG_cnProcBuf[6] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[7] = NULL;
+            p_lut->idxBnInSG_cnProcBuf[8] = NULL;
+
+            p_lut->startAddrSG_cnProcBuf[0] = NULL;
+            p_lut->startAddrSG_cnProcBuf[1] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG4_R23;
+            p_lut->startAddrSG_cnProcBuf[2] = NULL;
+            p_lut->startAddrSG_cnProcBuf[3] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG6_R23;
+            p_lut->startAddrSG_cnProcBuf[4] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG8_R23;
+            p_lut->startAddrSG_cnProcBuf[5] = (const uint16_t**) startAddrBnProcBuf_BG2_CNG10_R23;
+            p_lut->startAddrSG_cnProcBuf[6] = NULL;
+            p_lut->startAddrSG_cnProcBuf[7] = NULL;
+            p_lut->startAddrSG_cnProcBuf[8] = NULL;
+
+            p_lut->listStartAddrSG[0] = NULL;
+            p_lut->listStartAddrSG[1] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG4_R23;
+            p_lut->listStartAddrSG[2] = NULL;
+            p_lut->listStartAddrSG[3] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG6_R23;
+            p_lut->listStartAddrSG[4] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG8_R23;
+            p_lut->listStartAddrSG[5] = (const uint16_t*) startAddrBnProcBufSG_BG2_CNG10_R23;
+            p_lut->listStartAddrSG[6] = NULL;
+            p_lut->listStartAddrSG[7] = NULL;
+            p_lut->listStartAddrSG[8] = NULL;
+
+            p_lut->startAddrLlrSG[0] = NULL;
+            p_lut->startAddrLlrSG[1] = (const uint16_t*) startAddrLlrSG_BG2_CNG4_R23;
+            p_lut->startAddrLlrSG[2] = NULL;
+            p_lut->startAddrLlrSG[3] = (const uint16_t*) startAddrLlrSG_BG2_CNG6_R23;
+            p_lut->startAddrLlrSG[4] = (const uint16_t*) startAddrLlrSG_BG2_CNG8_R23;
+            p_lut->startAddrLlrSG[5] = (const uint16_t*) startAddrLlrSG_BG2_CNG10_R23;
+            p_lut->startAddrLlrSG[6] = NULL;
+            p_lut->startAddrLlrSG[7] = NULL;
+            p_lut->startAddrLlrSG[8] = NULL;
         }
 
         // LUT that depend on Z and R
@@ -885,7 +1155,6 @@ static inline uint32_t nrLDPC_init(t_nrLDPC_dec_params* p_decParams, t_nrLDPC_lu
             p_lut->numBnInBnGroups = lut_numBnInBnGroups_BG1_R13;
             p_lut->startAddrBnGroups = lut_startAddrBnGroups_BG1_R13;
             p_lut->startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R13;
-
             numLLR = NR_LDPC_NCOL_BG1_R13*Z;
         }
         else if (R == 23)

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init_mem.h

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*!\file nrLDPC_init_mem.h
+ * \brief Defines the function to initialize the LDPC decoder and sets correct LUTs.
+ * \author Sebastian Wagner (TCL Communications) Email: <mailto:sebastian.wagner@tcl.com>
+ * \date 07-12-2018
+ * \version 1.0
+ * \note
+ * \warning
+ */
+
+#ifndef __NR_LDPC_INIT_MEM__H__
+#define __NR_LDPC_INIT_MEM__H__
+
+#include <stdlib.h>
+#include "nrLDPC_types.h"
+
+/**
+   \brief Allocates 32 byte aligned memory and initializes to zero
+   \param size Input size in bytes
+   \return Pointer to memory
+*/
+static inline void* malloc32_clear(size_t size)
+{
+    void* ptr = (void*) memalign(32, size+32);
+    memset(ptr, 0, size);
+    return ptr;
+}
+
+/**
+   \brief Allocates and initializes the internal decoder processing buffers
+   \param p_decParams Pointer to decoder parameters
+   \param p_lut Pointer to decoder LUTs
+   \return Number of LLR values
+*/
+static inline t_nrLDPC_procBuf* nrLDPC_init_mem(void)
+{
+    t_nrLDPC_procBuf* p_procBuf = (t_nrLDPC_procBuf*) malloc32_clear(sizeof(t_nrLDPC_procBuf));
+
+    if (p_procBuf)
+    {
+        p_procBuf->cnProcBuf    = (int8_t*) malloc32_clear(NR_LDPC_SIZE_CN_PROC_BUF*sizeof(int8_t));
+        p_procBuf->cnProcBufRes = (int8_t*) malloc32_clear(NR_LDPC_SIZE_CN_PROC_BUF*sizeof(int8_t));
+        p_procBuf->bnProcBuf    = (int8_t*) malloc32_clear(NR_LDPC_SIZE_BN_PROC_BUF*sizeof(int8_t));
+        p_procBuf->bnProcBufRes = (int8_t*) malloc32_clear(NR_LDPC_SIZE_BN_PROC_BUF*sizeof(int8_t));
+        p_procBuf->llrRes       = (int8_t*) malloc32_clear(NR_LDPC_MAX_NUM_LLR     *sizeof(int8_t));
+        p_procBuf->llrProcBuf   = (int8_t*) malloc32_clear(NR_LDPC_MAX_NUM_LLR     *sizeof(int8_t));
+        p_procBuf->bnProcBufTemp = (int8_t*) malloc32_clear(NR_LDPC_MAX_NUM_LLR     *sizeof(int8_t));
+    }
+
+    return(p_procBuf);
+}
+
+static inline void nrLDPC_free_mem(t_nrLDPC_procBuf* p_procBuf)
+{
+    free(p_procBuf->cnProcBuf);
+    free(p_procBuf->cnProcBufRes);
+    free(p_procBuf->bnProcBuf);
+    free(p_procBuf->bnProcBufRes);
+    free(p_procBuf->llrRes);
+    free(p_procBuf->llrProcBuf);
+    free(p_procBuf->bnProcBufTemp);
+
+    free(p_procBuf);
+}
+#endif

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_lut.h

@@ -1001,4 +1001,172 @@ static const uint8_t posBnInCnProcBuf_BG2_CNG6[6][3] = {{0, 0, 1},{1, 5, 5},{5,
 static const uint8_t posBnInCnProcBuf_BG2_CNG8[8][2] = {{0, 0},{1, 1},{2, 3},{3, 4},{6, 8},{9, 10},{10, 12},{11, 13}};
 static const uint8_t posBnInCnProcBuf_BG2_CNG10[10][2] = {{0, 1},{3, 2},{4, 4},{5, 5},{6, 6},{7, 7},{8, 8},{9, 9},{11, 10},{12, 13}};
 
+// R15
+// CNG3
+static const uint16_t numSG_BG2_CNG3_R15 = 3;
+static const uint16_t listSG_BG2_CNG3_R15[3] = {1, 2, 3};
+static const uint16_t numBNinSG_BG2_CNG3_R15[3] = {11, 2, 1};
+static const uint16_t maxBnInSG_CNG3_R15 = 11;
+static const uint16_t bnIdx_BG2_CNG3_SG_R15[3][11] = {{2, 4, 5, 6, 10, 32, 35, 37, 39, 41, 47},{1, 13},{0}};
+static const uint16_t idxBnProcBuf_BG2_CNG3_R15[3][6] = {{0, 0, 0, 0, 0, 4},{0, 2, 3, 1, 1, 1},{5, 6, 7, 8, 9, 10}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG3_R15[3][6] = {{8448, 10752, 11136, 11520, 9216, 0},{0, 0, 0, 0, 8448, 9216},{0, 0, 0, 0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG3_R15[3] = {0, 8448, 10752};
+static const uint16_t startAddrLlrSG_BG2_CNG3_R15[6] = {4224, 9984, 11904};
+
+// CNG4
+static const uint16_t numSG_BG2_CNG4_R15 = 9;
+static const uint16_t listSG_BG2_CNG4_R15[9] = {1, 2, 3, 4, 5, 6, 7, 10, 11};
+static const uint16_t numBNinSG_BG2_CNG4_R15[9] = {24, 1, 1, 3, 1, 1, 1, 1, 1};
+static const uint16_t maxBnInSG_CNG4_R15 = 24;
+static const uint16_t bnIdx_BG2_CNG4_SG_R15[9][24] = {{4, 6, 8, 9, 14, 18, 22, 25, 28, 29, 30, 31, 33, 34, 38, 42, 43, 44, 45, 46, 48, 49, 50, 51},{3},{13},{7, 10, 12},{2},{5},{11},{1},{0}};
+static const uint16_t idxBnProcBuf_BG2_CNG4_R15[4][20] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},{0, 0, 0, 1, 1, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0},{0, 2, 0, 0, 0, 1, 0, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 0},{4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG4_R15[4][20] = {{39168, 39552, 34944, 39936, 40320, 40704, 35328, 41088, 41472, 35712, 36096, 41856, 26880, 42240, 36480, 42624, 36864, 43008, 27264, 37248},{37632, 38016, 18432, 21120, 0, 38400, 0, 0, 18816, 27648, 28032, 29184, 21120, 21120, 29568, 28416, 29952, 22272, 22272, 30336},{31872, 22272, 32256, 32640, 23424, 23424, 33024, 19584, 30720, 0, 31104, 23424, 24576, 19968, 33408, 24576, 33792, 24576, 20352, 34176},{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG4_R15[9] = {0, 18432, 19584, 21120, 26880, 29184, 31872, 34944, 39168};
+static const uint16_t startAddrLlrSG_BG2_CNG4_R15[20] = {9216, 19200, 20736, 25728, 28800, 31488, 34560, 38784, 43392};
+
+// CNG5
+static const uint16_t numSG_BG2_CNG5_R15 = 5;
+static const uint16_t listSG_BG2_CNG5_R15[5] = {1, 2, 3, 4, 6};
+static const uint16_t numBNinSG_BG2_CNG5_R15[5] = {10, 4, 3, 3, 1};
+static const uint16_t maxBnInSG_CNG5_R15 = 10;
+static const uint16_t bnIdx_BG2_CNG5_SG_R15[5][10] = {{10, 19, 20, 21, 23, 24, 26, 27, 36, 40},{2, 5, 6, 8},{0, 9, 12},{7, 11, 13},{1}};
+static const uint16_t idxBnProcBuf_BG2_CNG5_R15[5][9] = {{0, 0, 0, 0, 0, 0, 0, 0, 0},{3, 0, 0, 0, 2, 1, 1, 0, 1},{0, 2, 1, 3, 1, 1, 1, 2, 0},{1, 0, 2, 2, 2, 2, 2, 2, 1},{1, 2, 3, 4, 5, 6, 7, 8, 9}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG5_R15[5][9] = {{22656, 12288, 13440, 14592, 23040, 23424, 23808, 7680, 9216},{7680, 24192, 16896, 24576, 7680, 12288, 7680, 18048, 9216},{0, 9216, 13440, 9216, 16896, 18048, 19200, 12288, 19200},{20352, 20352, 16896, 18048, 19200, 13440, 14592, 20352, 14592},{0, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG5_R15[5] = {0, 7680, 12288, 16896, 22656};
+static const uint16_t startAddrLlrSG_BG2_CNG5_R15[9] = {3840, 10752, 15744, 21504, 24960};
+
+// CNG6
+static const uint16_t numSG_BG2_CNG6_R15 = 3;
+static const uint16_t listSG_BG2_CNG6_R15[3] = {1, 2, 3};
+static const uint16_t numBNinSG_BG2_CNG6_R15[3] = {5, 2, 3};
+static const uint16_t maxBnInSG_CNG6_R15 = 5;
+static const uint16_t bnIdx_BG2_CNG6_SG_R15[3][5] = {{9, 13, 15, 16, 17},{0, 1},{5, 7, 11}};
+static const uint16_t idxBnProcBuf_BG2_CNG6_R15[6][3] = {{0, 0, 1},{1, 0, 0},{0, 1, 1},{1, 0, 2},{2, 2, 1},{2, 3, 4}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG6_R15[6][3] = {{3840, 4608, 3840},{4608, 6144, 7296},{8448, 6144, 7296},{8448, 0, 6144},{7296, 8448, 0},{0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG6_R15[3] = {0, 3840, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG6_R15[3] = {1920, 5376, 9600};
+
+// CNG8
+static const uint16_t numSG_BG2_CNG8_R15 = 2;
+static const uint16_t listSG_BG2_CNG8_R15[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG8_R15[2] = {8, 4};
+static const uint16_t maxBnInSG_CNG8_R15 = 8;
+static const uint16_t bnIdx_BG2_CNG8_SG_R15[2][8] = {{2, 4, 6, 8, 9, 11, 12, 13},{0, 1, 3, 10}};
+static const uint16_t idxBnProcBuf_BG2_CNG8_R15[8][2] = {{0, 0},{1, 1},{0, 2},{2, 1},{2, 3},{4, 3},{3, 6},{5, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG8_R15[8][2] = {{6144, 7680},{6144, 7680},{0, 6144},{7680, 0},{0, 0},{0, 6144},{7680, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG8_R15[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG8_R15[2] = {3072, 9216};
+
+// CNG10
+static const uint16_t numSG_BG2_CNG10_R15 = 2;
+static const uint16_t listSG_BG2_CNG10_R15[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG10_R15[2] = {8, 6};
+static const uint16_t maxBnInSG_CNG10_R15 = 8;
+static const uint16_t bnIdx_BG2_CNG10_SG_R15[2][8] = {{0, 1, 2, 3, 10, 11, 12, 13},{4, 5, 6, 7, 8, 9}};
+static const uint16_t idxBnProcBuf_BG2_CNG10_R15[10][2] = {{0, 1},{3, 2},{0, 0},{1, 1},{2, 2},{3, 3},{4, 4},{5, 5},{5, 4},{6, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG10_R15[10][2] = {{0, 0},{0, 0},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{0, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG10_R15[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG10_R15[2] = {3072, 10752};
+
+// R13
+// CNG4
+static const uint16_t numSG_BG2_CNG4_R13 = 5;
+static const uint16_t listSG_BG2_CNG4_R13[5] = {1, 2, 4, 5, 6};
+static const uint16_t numBNinSG_BG2_CNG4_R13[5] = {15, 1, 1, 1, 1};
+static const uint16_t maxBnInSG_CNG4_R13 = 5;
+static const uint16_t bnIdx_BG2_CNG4_SG_R13[5][15] = {{3, 4, 6, 7, 8, 12, 13, 14, 18, 22, 25, 28, 29, 30, 31},{10},{11},{1},{0}};
+static const uint16_t idxBnProcBuf_BG2_CNG4_R13[4][8] = {{0, 0, 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 2, 0, 1, 4},{0, 5, 0, 0, 3, 0, 0, 6},{7, 8, 9, 10, 11, 12, 13, 14}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG4_R13[4][8] = {{16896, 17280, 14592, 17664, 18048, 18432, 14976, 18816},{15360, 15744, 0, 11520, 0, 16128, 0, 0},{12672, 0, 13056, 13440, 0, 11904, 13824, 0},{0, 0, 0, 0, 0, 0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG4_R13[5] = {0, 11520, 12672, 14592, 16896};
+static const uint16_t startAddrLlrSG_BG2_CNG4_R13[8] = {5760, 12288, 14208, 16512, 19200};
+
+// CNG5
+static const uint16_t numSG_BG2_CNG5_R13 = 5;
+static const uint16_t listSG_BG2_CNG5_R13[5] = {1, 2, 3, 4, 6};
+static const uint16_t numBNinSG_BG2_CNG5_R13[5] = {9, 5, 2, 1, 1};
+static const uint16_t maxBnInSG_CNG5_R13 = 5;
+static const uint16_t bnIdx_BG2_CNG5_SG_R13[5][9] = {{5, 10, 19, 20, 21, 23, 24, 26, 27},{6, 7, 8, 9, 12},{0, 13},{11},{1}};
+static const uint16_t idxBnProcBuf_BG2_CNG5_R13[5][7] = {{0, 0, 0, 0, 0, 0, 0},{2, 0, 1, 0, 0, 3, 0},{1, 0, 3, 2, 0, 0, 0},{0, 1, 1, 1, 1, 4, 4},{2, 3, 4, 5, 6, 7, 8}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG5_R13[5][7] = {{17664, 12672, 13440, 14208, 18048, 18432, 18816},{6912, 19200, 6912, 19584, 6912, 6912, 0},{0, 8832, 8832, 8832, 15744, 16128, 16512},{16896, 8832, 12672, 13440, 14208, 6912, 8832},{0, 0, 0, 0, 0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG5_R13[5] = {0, 6912, 12672, 15744, 17664};
+static const uint16_t startAddrLlrSG_BG2_CNG5_R13[7] = {3456, 10752, 14976, 17280, 19968};
+
+// CNG6
+static const uint16_t numSG_BG2_CNG6_R13 = 3;
+static const uint16_t listSG_BG2_CNG6_R13[3] = {1, 2, 3};
+static const uint16_t numBNinSG_BG2_CNG6_R13[3] = {5, 2, 3};
+static const uint16_t maxBnInSG_CNG6_R13 = 5;
+static const uint16_t bnIdx_BG2_CNG6_SG_R13[3][5] = {{9, 13, 15, 16, 17},{0, 1},{5, 7, 11}};
+static const uint16_t idxBnProcBuf_BG2_CNG6_R13[6][3] = {{0, 0, 1},{1, 0, 0},{0, 1, 1},{1, 0, 2},{2, 2, 1},{2, 3, 4}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG6_R13[6][3] = {{3840, 4608, 3840},{4608, 6144, 7296},{8448, 6144, 7296},{8448, 0, 6144},{7296, 8448, 0},{0, 0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG6_R13[3] = {0, 3840, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG6_R13[3] = {1920, 5376, 9600};
+
+// CNG8
+static const uint16_t numSG_BG2_CNG8_R13 = 2;
+static const uint16_t listSG_BG2_CNG8_R13[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG8_R13[2] = {8, 4};
+static const uint16_t maxBnInSG_CNG8_R13 = 8;
+static const uint16_t bnIdx_BG2_CNG8_SG_R13[2][8] = {{2, 4, 6, 8, 9, 11, 12, 13},{0, 1, 3, 10}};
+static const uint16_t idxBnProcBuf_BG2_CNG8_R13[8][2] = {{0, 0},{1, 1},{0, 2},{2, 1},{2, 3},{4, 3},{3, 6},{5, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG8_R13[8][2] = {{6144, 7680},{6144, 7680},{0, 6144},{7680, 0},{0, 0},{0, 6144},{7680, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG8_R13[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG8_R13[2] = {3072, 9216};
+
+// CNG10
+static const uint16_t numSG_BG2_CNG10_R13 = 2;
+static const uint16_t listSG_BG2_CNG10_R13[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG10_R13[2] = {8, 6};
+static const uint16_t maxBnInSG_CNG10_R13 = 8;
+static const uint16_t bnIdx_BG2_CNG10_SG_R13[2][8] = {{0, 1, 2, 3, 10, 11, 12, 13},{4, 5, 6, 7, 8, 9}};
+static const uint16_t idxBnProcBuf_BG2_CNG10_R13[10][2] = {{0, 1},{3, 2},{0, 0},{1, 1},{2, 2},{3, 3},{4, 4},{5, 5},{5, 4},{6, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG10_R13[10][2] = {{0, 0},{0, 0},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{0, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG10_R13[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG10_R13[2] = {3072, 10752};
+
+// R23
+// CNG4
+static const uint16_t numSG_BG2_CNG4_R23 = 1;
+static const uint16_t listSG_BG2_CNG4_R23[1] = {1};
+static const uint16_t numBNinSG_BG2_CNG4_R23[1] = {4};
+static const uint16_t maxBnInSG_CNG4_R23 = 1;
+static const uint16_t bnIdx_BG2_CNG4_SG_R23[1][4] = {{0, 1, 11, 14}};
+static const uint16_t idxBnProcBuf_BG2_CNG4_R23[4][1] = {{0},{1},{2},{3}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG4_R23[4][1] = {{0},{0},{0},{0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG4_R23[1] = {0};
+static const uint16_t startAddrLlrSG_BG2_CNG4_R23[1] = {1536};
+
+// CNG6
+static const uint16_t numSG_BG2_CNG6_R23 = 2;
+static const uint16_t listSG_BG2_CNG6_R23[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG6_R23[2] = {4, 4};
+static const uint16_t maxBnInSG_CNG6_R23 = 4;
+static const uint16_t bnIdx_BG2_CNG6_SG_R23[2][4] = {{1, 9, 15, 16},{0, 5, 7, 11}};
+static const uint16_t idxBnProcBuf_BG2_CNG6_R23[6][2] = {{0, 0},{0, 1},{1, 2},{2, 1},{3, 3},{2, 3}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG6_R23[6][2] = {{3072, 4608},{0, 3072},{4608, 3072},{4608, 0},{3072, 4608},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG6_R23[2] = {0, 3072};
+static const uint16_t startAddrLlrSG_BG2_CNG6_R23[2] = {1536, 6144};
+
+// CNG8
+static const uint16_t numSG_BG2_CNG8_R23 = 2;
+static const uint16_t listSG_BG2_CNG8_R23[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG8_R23[2] = {8, 4};
+static const uint16_t maxBnInSG_CNG8_R23 = 8;
+static const uint16_t bnIdx_BG2_CNG8_SG_R23[2][8] = {{2, 4, 6, 8, 9, 11, 12, 13},{0, 1, 3, 10}};
+static const uint16_t idxBnProcBuf_BG2_CNG8_R23[8][2] = {{0, 0},{1, 1},{0, 2},{2, 1},{2, 3},{4, 3},{3, 6},{5, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG8_R23[8][2] = {{6144, 7680},{6144, 7680},{0, 6144},{7680, 0},{0, 0},{0, 6144},{7680, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG8_R23[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG8_R23[2] = {3072, 9216};
+
+// CNG10
+static const uint16_t numSG_BG2_CNG10_R23 = 2;
+static const uint16_t listSG_BG2_CNG10_R23[2] = {1, 2};
+static const uint16_t numBNinSG_BG2_CNG10_R23[2] = {8, 6};
+static const uint16_t maxBnInSG_CNG10_R23 = 8;
+static const uint16_t bnIdx_BG2_CNG10_SG_R23[2][8] = {{0, 1, 2, 3, 10, 11, 12, 13},{4, 5, 6, 7, 8, 9}};
+static const uint16_t idxBnProcBuf_BG2_CNG10_R23[10][2] = {{0, 1},{3, 2},{0, 0},{1, 1},{2, 2},{3, 3},{4, 4},{5, 5},{5, 4},{6, 7}};
+static const uint16_t startAddrBnProcBuf_BG2_CNG10_R23[10][2] = {{0, 0},{0, 0},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{6144, 8448},{0, 0},{0, 0}};
+static const uint16_t startAddrBnProcBufSG_BG2_CNG10_R23[2] = {0, 6144};
+static const uint16_t startAddrLlrSG_BG2_CNG10_R23[2] = {3072, 10752};
 #endif
+

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h

@@ -30,6 +30,7 @@
 
 #ifndef __NR_LDPC_MPASS__H__
 #define __NR_LDPC_MPASS__H__
+#define NR_LDPC_PROC_DEBUG
 
 #include <string.h>
 #include "nrLDPCdecoder_defs.h"
@@ -75,6 +76,19 @@ static inline void *nrLDPC_circ_memcpy(int8_t *str1, const int8_t *str2, uint16_
     return(str1);
 }
 
+static inline void nrLDPC_llr2llrProcBuf_layer(t_nrLDPC_lut* p_lut, int8_t* llr, int8_t* llrProcBuf, uint16_t Z, uint8_t BG)
+{
+  int numCols = (BG == 1) ? NR_LDPC_NCOL_BG1 : NR_LDPC_NCOL_BG2;
+  memcpy(&llrProcBuf[0], &llr[0], numCols*Z);
+}
+
+static inline void nrLDPC_llrRes2llrOut_layer(t_nrLDPC_lut* p_lut, int8_t* llrOut, int8_t* llrDecoded, uint16_t Z, uint8_t BG)
+{
+  int numCols = (BG == 1) ? NR_LDPC_NCOL_BG1 : NR_LDPC_NCOL_BG2;
+  memcpy(llrOut, &llrOut[0], numCols*Z);
+}
+
+
 /**
    \brief Copies the input LLRs to their corresponding place in the LLR processing buffer.
    Example: BG2

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h

@@ -51,6 +51,17 @@ typedef struct nrLDPC_lut {
     const uint16_t* llr2llrProcBufAddr; /**< LUT for transferring input LLRs to LLR processing buffer */
     const uint8_t*  llr2llrProcBufBnPos; /**< LUT BN position in BG */
     const uint8_t** posBnInCnProcBuf[NR_LDPC_NUM_CN_GROUPS_BG1]; /**< LUT for llr2cnProcBuf */
+
+    // Following structs are used for layer schedule processing
+    const uint16_t* numSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t* listSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t* numBnInSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t* maxBnInSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t** bnPosSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t** idxBnInSG_cnProcBuf[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t** startAddrSG_cnProcBuf[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t* listStartAddrSG[NR_LDPC_NUM_CN_GROUPS_BG1];
+    const uint16_t* startAddrLlrSG[NR_LDPC_NUM_CN_GROUPS_BG1];
 } t_nrLDPC_lut;
 
 /**
@@ -62,6 +73,14 @@ typedef enum nrLDPC_outMode {
     nrLDPC_outMode_LLRINT8 /**< Single LLR value per int8_t output */
 } e_nrLDPC_outMode;
 
+/**
+   Enum for decoder mode
+ */
+typedef enum nrLDPC_decMode {
+    nrLDPC_decMode_flooding,
+    nrLDPC_decMode_layerCNG
+} e_nrLDPC_decMode;
+
 /**
    Structure containing LDPC decoder parameters.
  */
@@ -72,6 +91,7 @@ typedef struct nrLDPC_dec_params {
     uint8_t numMaxIter; /**< Maximum number of iterations */
     int block_length;
     e_nrLDPC_outMode outMode; /**< Output format */
+    e_nrLDPC_decMode decMode; /**< Decoder mode */
 } t_nrLDPC_dec_params;
 
 /**
@@ -99,6 +119,7 @@ typedef struct nrLDPC_procBuf {
     int8_t* cnProcBufRes; /**< Buffer for CN processing results */
     int8_t* bnProcBuf; /**< BN processing buffer */
     int8_t* bnProcBufRes; /**< Buffer for BN processing results */
+    int8_t* bnProcBufTemp; /**< Temporary buffer for storing intermitent results */
     int8_t* llrRes; /**< Buffer for LLR results */
     int8_t* llrProcBuf; /**< LLR processing buffer */
 } t_nrLDPC_procBuf;

openair1/PHY/CODING/nrLDPC_decoder/scripts/nrLdpcDecoderIndexCalc.m

@@ -0,0 +1,570 @@
+% Script to create index tables from base graphs
+
+% Read BGs from xlsx file
+% BG1
+columnIndex_BG1   = xlsread('nrLDPC_BG1.xlsx',1);
+numColsPerRow_BG1 = xlsread('nrLDPC_BG1.xlsx',2);
+shiftValues_BG1   = xlsread('nrLDPC_BG1.xlsx',3);
+% BG2
+columnIndex_BG2   = xlsread('nrLDPC_BG2.xlsx',1);
+numColsPerRow_BG2 = xlsread('nrLDPC_BG2.xlsx',2);
+shiftValues_BG2   = xlsread('nrLDPC_BG2.xlsx',3);
+
+% Size of BGs (Mb x Nb)
+Mb1 = 46;
+Nb1 = 68;
+Mb2 = 42;
+Nb2 = 52;
+
+% Sets if LDPC lifting sizes
+liftingSizes = [ 2  4  8  16  32  64 128 256 ; ...
+                 3  6 12  24  48  96 192 384 ; ...
+                 5 10 20  40  80 160 320   0 ; ...
+                 7 14 28  56 112 224   0   0 ; ...
+                 9 18 36  72 144 288   0   0 ; ...
+                11 22 44  88 176 352   0   0 ; ...
+                13 26 52 104 208   0   0   0 ; ...
+                15 30 60 120 240   0   0   0 ];
+
+NR_LDPC_ZMAX = 384;
+
+plotBG = 0;
+
+% Parameters for BG selection
+BG = 2;
+Z = 384;
+R = 23;
+
+switch R
+    case 15
+        r = 1/5;
+    case 13
+        r = 1/3;
+    case 23
+        r = 2/3;
+    case 89
+        r = 8/9;
+    otherwise
+        r = 1/5;
+end
+
+% allZ = sort(liftingSizes(liftingSizes>0));
+allZ = 2;
+group = 6;
+for iZ = 1:length(allZ)
+    Z = allZ(iZ);
+
+% Select lifting set index
+[iLS, ~] = find(liftingSizes == Z);
+
+%% Create BG matrix
+if (BG == 1)
+    columnIndex   = columnIndex_BG1;
+    numColsPerRow_BG = numColsPerRow_BG1;
+    shiftValues   = shiftValues_BG1(:,iLS);
+    Mb = Mb1;
+    Nb = Nb1;
+    K  = 22;
+    NR_LDPC_START_COL_PARITY = 26;
+elseif (BG == 2)
+    columnIndex   = columnIndex_BG2;
+    numColsPerRow_BG = numColsPerRow_BG2;
+    shiftValues   = shiftValues_BG2(:,iLS);
+    Mb = Mb2;
+    Nb = Nb2;
+    K  = 10;
+    NR_LDPC_START_COL_PARITY = 14;
+else
+    error('Unknown BG');
+end
+shiftValues = mod(shiftValues, Z);
+
+
+% Calculate effective BG
+% fprintf('<Parameters>\n');
+% fprintf('BG = %d\n', BG);
+% fprintf('R  = %d\n', R);
+
+Nb = ceil(K/r) + 2;
+Mb = Nb - K;
+numColsPerRow = numColsPerRow_BG(1:Mb);
+
+Hb = -ones(Mb, Nb);
+Hb(1,columnIndex(1:numColsPerRow(1))+1) = shiftValues(1:numColsPerRow(1));
+for irow = 2:Mb
+    idx = sum(numColsPerRow(1:(irow-1)))+1:sum(numColsPerRow(1:irow));
+    idxCols = columnIndex(idx) + 1;
+    
+    Hb(irow, idxCols) = shiftValues(idx);
+end
+
+if plotBG == 1
+    NO_SHIFT = max(shiftValues)+1;
+    Hb(Hb==-1) = NO_SHIFT;
+    imagesc(Hb);
+    cmap = jet(max(Hb(:)));
+    cmap(end,:) = ones(1,3);
+    colormap(cmap);
+    colorbar;
+    grid on; xticks(0:5:Nb);
+    Hb(Hb==NO_SHIFT) = -1;
+end
+
+numCNperBN = sum(Hb~=-1,1);
+numBNperCN = sum(Hb~=-1,2);
+
+cnGroups = unique(numBNperCN);
+bnGroups = unique(numCNperBN);
+
+numCNperBNGroup = sum((numCNperBN' == bnGroups),1);
+numEdgesPerBNGroup = bnGroups.*numCNperBNGroup;
+
+picBG = [numCNperBN;Hb];
+picBG = [[0;numBNperCN],picBG];
+
+% Shift values per group
+numCNinGroup = sum(numColsPerRow==group);
+
+% Start adresses in BN proc buffer
+[x,~] = find(numColsPerRow==group);
+y = mod(reshape(find(Hb(x,:)'~=-1),group,numCNinGroup)',Nb);
+y(y==0) = Nb;
+
+yUnique = unique(y);
+
+bnProcBuffCpyOffset = (y-1);
+bnSubGroup = zeros(group,length(yUnique));
+
+startAddr = zeros(numCNinGroup,group);
+cshift = zeros(numCNinGroup,group);
+bnPos = zeros(numCNinGroup,group);
+for n=1:group
+    for k=1:numCNinGroup
+        
+        bnGroup = numCNperBN(y(k,n));        
+        bnGroupIdx = find(bnGroups == numCNperBN(y(k,n)));
+
+        startAddrBnGroup = sum(numEdgesPerBNGroup(1:(bnGroupIdx-1)))*NR_LDPC_ZMAX;        
+        offsetCnInBnGroup = numCNperBNGroup(bnGroupIdx) * ((sum(Hb(1:x(k),y(k,n))~=-1)-1)) * NR_LDPC_ZMAX;
+%         offsetBnInCn = sum(numCNperBN(:,1:y(k,n)-1)==bnGroup)*Z;
+        offsetBnInCn = 0;
+        bnPos(k,n) = sum(numCNperBN(:,1:y(k,n)-1)==bnGroup);
+        
+        startAddr(k,n) = startAddrBnGroup + offsetCnInBnGroup + offsetBnInCn;
+        cshift(k,n) = Hb(x(k),y(k,n));
+    end
+    bnSubGroup(n,:) = sum(yUnique'==y(:,n),1);
+end
+
+bnSubGroupNum = zeros(1,length(yUnique));
+addrOffset = [];
+for i = 1:length(yUnique)
+    bnIdx = yUnique(i);
+    bnSubGroupNum(i) = sum((bnIdx==y),'all');
+    idxY = find(bnIdx==y);
+    addrOffset = [addrOffset, NR_LDPC_ZMAX*(idxY-1)'];
+end
+yUnique = yUnique(:).';
+% print_bnSubGroupAddr(addrOffset,BG,R,group,bnSubGroupNum);
+bnSubGroupIdx_cell = print_bnSubGroupIdx(BG,R,group,bnSubGroupNum,yUnique);
+[idxBnProcBuf,startAddrBnProcBuf,startAddrLlrSG,startAddrBnProcBufSG] = print_addrBnProcBuf(y-1,bnSubGroupIdx_cell,bnSubGroupNum,NR_LDPC_ZMAX);
+print_bnProcBufLUTs(idxBnProcBuf,startAddrBnProcBuf,startAddrLlrSG,startAddrBnProcBufSG,numCNinGroup,group,BG,R);
+% print_bnSubGroupCshift(BG,R,Z,group,bnSubGroupNum,cshift);
+% print_cshift(cshift,BG,Z,group,numCNinGroup);
+% print_startAddr(startAddr,BG,R,group,numCNinGroup);
+% print_bnPos(bnPos,BG,R,group,numCNinGroup);
+ 
+% LUT for llr2CnProcBuf
+print_posBnInCnProcBuf(y-1,BG,group,numCNinGroup);
+
+% LUT for llr2llrProcBuf
+% LLR processing buffer org
+% bnGroups  |1 |4 |5 |6 |7 |8 |9 |10|11|12|13|28|30|
+% numofBnGr |42|1 |1 |2 |4 |3 |1 |4 |3 |4 | 1| 1| 1|
+% startAddr       ^                             ^
+%              42*Z_MAX                      67*Z_MAX
+startAddrLlrProc = tril(ones(length(numCNperBNGroup)))*[0 numCNperBNGroup(1:end-1)]'*NR_LDPC_ZMAX;
+
+colParity = sum(numCNperBN>1);
+numCNperBNnoParity = numCNperBN(1:colParity);
+
+startAddr = zeros(length(numCNperBNnoParity),1);
+bnPos = zeros(length(numCNperBNnoParity),1);
+numBn = ones(length(numCNperBNnoParity),1);
+bnGroup = numCNperBNnoParity(1);
+bnGroupIdx = find(bnGroups == bnGroup);
+% 
+% startAddr(1) = startAddrLlrProc(bnGroupIdx);
+% idx = 2;
+for k=1:length(numCNperBNnoParity)    
+    bnGroup = numCNperBNnoParity(k);
+    bnGroupIdx = find(bnGroups == bnGroup);
+    startAddr(k) = startAddrLlrProc(bnGroupIdx);
+    bnPos(k) = sum(numCNperBNnoParity(:,1:k-1)==bnGroup);
+    
+%     bnPosCur = sum(numCNperBNnoParity(:,1:k-1)==bnGroup);
+%     addr = startAddrLlrProc(bnGroupIdx);
+%         
+%     if (bnGroup == numCNperBNnoParity(k-1))        
+%         numBn(idx-1) = numBn(idx-1) + 1;
+%     else
+%         startAddr(idx) = addr;
+%         bnPos(idx) = bnPosCur;
+%         idx = idx + 1;
+%     end
+end
+% bnPos = bnPos(startAddr > 0);
+% startAddr = startAddr(startAddr > 0);
+% 
+% numBn = numBn(1:length(startAddr));
+
+% print_llr2llrProcBuf(startAddr,bnPos,numBn,BG,R);
+
+end
+
+
+
+function print_bnProcBufLUTs(idxBnProcBuf,startAddrBnProcBuf,startAddrLlrSG,startAddrBnProcBufSG,numCNinGroup,group,BG,R)
+
+prefix = 'static const uint16_t';
+%%%%%%%%
+idxBnProcBuf = reshape(idxBnProcBuf,[numCNinGroup,group]);
+arrayName = strcat('idxBnProcBuf', '_BG', num2str(BG), '_CNG',num2str(group),...
+            '_R',num2str(R),'[',num2str(group),'][',num2str(numCNinGroup),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{{');
+
+for j=1:group-1
+    for i=idxBnProcBuf(1:end-1,j)
+        if ~isempty(i)
+            fprintf('%d, ',i)
+        end
+    end
+    fprintf('%d},{',idxBnProcBuf(end,j));   
+end
+for i=idxBnProcBuf(1:end-1,group)
+    if ~isempty(i)
+        fprintf('%d, ',i)
+    end
+end
+fprintf('%d}',idxBnProcBuf(end,group));   
+fprintf('};\n');
+
+%%%%%%%%
+startAddrBnProcBuf = reshape(startAddrBnProcBuf,[numCNinGroup,group]);
+arrayName = strcat('startAddrBnProcBuf', '_BG', num2str(BG), '_CNG',num2str(group),...
+            '_R',num2str(R),'[',num2str(group),'][',num2str(numCNinGroup),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{{');
+
+for j=1:group-1
+    for i=startAddrBnProcBuf(1:end-1,j)
+        if ~isempty(i)
+            fprintf('%d, ',i)
+        end
+    end
+    fprintf('%d},{',startAddrBnProcBuf(end,j));   
+end
+for i=startAddrBnProcBuf(1:end-1,group)
+    if ~isempty(i)
+        fprintf('%d, ',i)
+    end
+end
+fprintf('%d}',startAddrBnProcBuf(end,group));   
+fprintf('};\n');
+
+%%%%%%%%
+arrayName = strcat('startAddrBnProcBufSG', '_BG', num2str(BG), '_CNG',num2str(group),...
+            '_R',num2str(R),'[',num2str(length(startAddrBnProcBufSG)),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{');
+for j=startAddrBnProcBufSG(1:end-1)
+    if ~isempty(j)
+        fprintf('%d, ',j)
+    end
+end
+fprintf('%d};\n',startAddrBnProcBufSG(end));
+
+%%%%%%%%
+arrayName = strcat('startAddrLlrSG', '_BG', num2str(BG), '_CNG',num2str(group),...
+            '_R',num2str(R),'[',num2str(numCNinGroup),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{');
+for j=startAddrLlrSG(1:end-1)
+    if ~isempty(j)
+        fprintf('%d, ',j)
+    end
+end
+fprintf('%d};\n',startAddrLlrSG(end));
+end
+
+function [idxBnProcBuf,startAddrBnProcBuf,startAddrLlrSG,startAddrBnProcBufSG] = print_addrBnProcBuf(y,bnSubGroupIdx_cell,bnSubGroupNum,NR_LDPC_ZMAX)
+
+uniqueSG = unique(bnSubGroupNum);
+uniqueSGSum = sum((uniqueSG'==bnSubGroupNum),2);
+
+for i=1:length(uniqueSG)
+    SG = uniqueSG(i);
+    bnInSG = bnSubGroupIdx_cell{i};
+    if i==1
+        startAddri = 0;
+    else
+        startAddri = startAddri+((uniqueSGSum(i-1)*uniqueSG(i-1)*NR_LDPC_ZMAX)+(uniqueSGSum(i-1)*NR_LDPC_ZMAX)); % +1 for input LLRs
+    end
+    startAddrBnProcBufSG(i) = startAddri;
+    if SG == 1      
+        a = 0;
+        for j=1:length(bnInSG)
+            idx = find(bnInSG(j)==y);
+            idxBnProcBuf(idx) = a;
+            startAddrBnProcBuf(idx) = startAddri;
+            a = a+1;
+        end
+    else
+        for j=1:length(bnInSG)
+            idx = find(bnInSG(j)==y);
+            for k = 1:length(idx)
+                idxBnProcBuf(idx(k)) = j-1;
+                startAddrBnProcBuf(idx(k)) = startAddri+(k-1)*uniqueSGSum(i)*NR_LDPC_ZMAX;
+            end
+        end
+    end
+    startAddrLlrSG(i) = startAddri+((uniqueSGSum(i)*uniqueSG(i)*NR_LDPC_ZMAX));
+end
+
+end
+
+function print_bnSubGroupAddr(addrOffset,BG,R,group,bnSubGroupNum)
+
+prefix = 'static const uint16_t';
+
+uniqueSG = unique(bnSubGroupNum);
+uniqueSGSum = sum((uniqueSG'==bnSubGroupNum),2);
+
+
+for i=1:length(uniqueSG)
+    SG = uniqueSG(i);
+    idxBnSubGroupNum = find(SG==bnSubGroupNum);
+    arrayName = strcat('addrOffset', '_BG', num2str(BG), '_CNG',num2str(group),...
+        '_SG',num2str(SG),'_R',num2str(R),'[',num2str(uniqueSGSum(i)),'][',num2str(SG),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{{');
+    for j=idxBnSubGroupNum(1:end-1)
+        s = sum(bnSubGroupNum(1:j-1),2);
+        y = addrOffset(s+1:s+SG);
+        if ~isempty(y(1:end-1))
+            fprintf('%d, ',y(1:end-1));
+        end
+        fprintf('%d},{',y(end));
+    end
+    j = idxBnSubGroupNum(end);
+    s = sum(bnSubGroupNum(1:j-1),2);
+    y = addrOffset(s+1:s+SG);
+    if ~isempty(y(1:end-1))
+        fprintf('%d, ',y(1:end-1));
+    end
+    fprintf('%d}',y(end));
+    fprintf('};\n');
+end
+    
+end
+
+function bnSubGroupIdx_cell = print_bnSubGroupIdx(BG,R,group,bnSubGroupNum,yUnique)
+
+prefix = 'static const uint16_t';
+bnSubGroupIdx_cell={};
+uniqueSG = unique(bnSubGroupNum);
+uniqueSGSum = sum((uniqueSG'==bnSubGroupNum),2);
+
+arrayName = strcat('numSG', '_BG', num2str(BG), '_CNG',num2str(group),...
+        '_R',num2str(R),' =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('%d;\n',length(uniqueSG));
+    
+arrayName = strcat('listSG', '_BG', num2str(BG), '_CNG',num2str(group),...
+        '_R',num2str(R),'[',num2str(length(uniqueSG)),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf(' {');
+for i=uniqueSG(1:end-1)
+    if ~isempty(i)
+        fprintf('%d, ',i);
+    end
+end
+fprintf('%d};\n',uniqueSG(end));
+
+arrayName = strcat('numBNinSG', '_BG', num2str(BG), '_CNG',num2str(group),...
+        '_R',num2str(R),'[',num2str(length(uniqueSG)),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf(' {');
+for i=uniqueSGSum(1:end-1)
+    if ~isempty(i)
+        fprintf('%d, ',i);
+    end
+end
+fprintf('%d};\n',uniqueSGSum(end));
+    
+arrayName = strcat('bnIdx', '_BG', num2str(BG), '_CNG',num2str(group),...
+        '_SG','_R',num2str(R),'[',num2str(length(uniqueSG)),']','[',num2str(max(uniqueSGSum)),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf(' {');
+for i=1:length(uniqueSG)
+    SG = uniqueSG(i);
+    bnSubGroupIdx_cell{i} = [];
+    idxBnSubGroupNum = SG==bnSubGroupNum;
+    fprintf('{');
+    y = (yUnique(idxBnSubGroupNum))-1;
+    if ~isempty(y(1:end-1))
+        fprintf('%d, ',y(1:end-1));
+        bnSubGroupIdx_cell{i} = [bnSubGroupIdx_cell{i}, y(1:end-1)];
+    end
+    fprintf('%d',y(end));
+    bnSubGroupIdx_cell{i} = [bnSubGroupIdx_cell{i}, y(end)];
+    fprintf('},');
+end
+fprintf('};\n');
+    
+end
+
+function print_bnSubGroupCshift(BG,R,Z,group,bnSubGroupNum,cshift)
+
+prefix = 'static const uint16_t';
+
+uniqueSG = unique(bnSubGroupNum);
+uniqueSGSum = sum((uniqueSG'==bnSubGroupNum),2);
+
+
+for i=1:length(uniqueSG)
+    SG = uniqueSG(i);
+    idxBnSubGroupNum = SG==bnSubGroupNum;
+    arrayName = strcat('bnIdxCshift', '_BG', num2str(BG),'_Z',num2str(Z), '_CNG',num2str(group),...
+        '_SG',num2str(SG),'_R',num2str(R),'[',num2str(uniqueSGSum(i)),'] =');
+    fprintf('%s %s ',prefix,arrayName);
+    fprintf('{');
+    y = (cshift(idxBnSubGroupNum));
+    if ~isempty(y(1:end-1))
+        fprintf('%d, ',y(1:end-1));
+    end
+    fprintf('%d',y(end));
+    fprintf('};\n');
+end
+    
+end
+
+function print_posBnInCnProcBuf(y,BG,group,numCNinGroup)
+
+prefix = 'static const uint8_t';
+
+arrayName = strcat('posBnInCnProcBuf', '_BG', num2str(BG), '_CNG',num2str(group),...
+    '[',num2str(group),'][',num2str(numCNinGroup),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{{');
+for n=1:group-1
+    if ~isempty(y(1:end-1,n))
+        fprintf('%d, ',y(1:end-1,n));
+    end
+    fprintf('%d},{',y(end,n));
+end
+if ~isempty(y(1:end-1,n))
+    fprintf('%d, ',y(1:end-1,group));
+end
+fprintf('%d}};\n',y(end,group));
+
+end
+
+function print_llr2llrProcBuf(startAddr,bnPos,numBn,BG,R)
+
+N = length(startAddr);
+prefix = 'static const uint16_t';
+
+arrayName = strcat('llr2llrProcBufAddr', '_BG', num2str(BG),'_R', num2str(R),...
+    '[',num2str(N),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{');
+fprintf('%d,',startAddr(1:end-1));
+fprintf('%d};\n',startAddr(end));
+
+prefix = 'static const uint8_t';
+
+arrayName = strcat('llr2llrProcBufBnPos', '_BG', num2str(BG),'_R', num2str(R),...
+    '[',num2str(N),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{');
+fprintf('%d,',bnPos(1:end-1));
+fprintf('%d};\n',bnPos(end));
+
+prefix = 'static const uint8_t';
+
+arrayName = strcat('llr2llrProcBufNumBn', '_BG', num2str(BG),'_R', num2str(R),...
+    '[',num2str(N),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{');
+fprintf('%d,',numBn(1:end-1));
+fprintf('%d};\n',numBn(end));
+end
+
+function print_bnPos(bnPos,BG,R,group,numCNinGroup)
+
+prefix = 'static const uint8_t';
+
+arrayName = strcat('bnPosBnProcBuf', '_BG', num2str(BG),'_R', num2str(R), '_CNG',num2str(group),...
+    '[',num2str(group),'][',num2str(numCNinGroup),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{{');
+for n=1:group-1
+    if ~isempty(bnPos(1:end-1,n))
+        fprintf('%d, ',bnPos(1:end-1,n));
+    end
+    fprintf('%d},{',bnPos(end,n));
+end
+if ~isempty(bnPos(1:end-1,n))
+    fprintf('%d, ',bnPos(1:end-1,group));
+end
+fprintf('%d}};\n',bnPos(end,group));
+end
+
+function print_startAddr(addr,BG,R,group,numCNinGroup)
+
+prefix = 'static const uint32_t';
+
+arrayName = strcat('startAddrBnProcBuf', '_BG', num2str(BG), '_R', num2str(R),'_CNG',num2str(group),...
+    '[',num2str(group),'][',num2str(numCNinGroup),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{{');
+for n=1:group-1
+    if ~isempty(addr(1:end-1,n))
+        fprintf('%d, ',addr(1:end-1,n));
+    end
+    fprintf('%d},{',addr(end,n));
+end
+if ~isempty(addr(1:end-1,n))
+    fprintf('%d, ',addr(1:end-1,group));
+end
+fprintf('%d}};\n',addr(end,group));
+end
+
+
+function print_cshift(cshift,BG,Z,group,numCNinGroup)
+    prefix = 'static const uint16_t';
+arrayName = strcat('circShift', '_BG', num2str(BG), '_Z', num2str(Z), '_CNG',num2str(group),...
+    '[',num2str(group),'][',num2str(numCNinGroup),'] =');
+
+fprintf('%s %s ',prefix,arrayName);
+fprintf('{{');
+for n=1:group-1
+    if ~isempty(cshift(1:end-1,n))
+        fprintf('%d, ',cshift(1:end-1,n));
+    end
+    fprintf('%d},{',cshift(end,n));
+end
+if ~isempty(cshift(1:end-1,n))
+    fprintf('%d, ',cshift(1:end-1,group));
+end
+fprintf('%d}};\n',cshift(end,group));
+end
+

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -537,6 +537,7 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 
   p_decParams->Z = harq_process->Z;
 
+  LOG_D(PHY,"BG %d, Z %d, R %d\n",p_decParams->BG,p_decParams->Z,p_decParams->R);
 
   p_decParams->numMaxIter = ulsch->max_ldpc_iterations;
   p_decParams->outMode= 0;

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -310,6 +310,7 @@ int main(int argc, char **argv)
   //float eff_tp_check = 0.7;
   uint8_t snrRun;
   int prb_inter = 0;
+  uint8_t max_rounds = 4;
 
   int enable_ptrs = 0;
   int modify_dmrs = 0;
@@ -343,7 +344,7 @@ int main(int argc, char **argv)
   /* initialize the sin-cos table */
    InitSinLUT();
 
-  while ((c = getopt(argc, argv, "a:b:c:d:ef:g:h:ikl:m:n:p:r:s:u:w:y:z:F:G:H:M:N:PR:S:T:U:L:Z")) != -1) {
+  while ((c = getopt(argc, argv, "a:b:c:d:ef:g:h:ikl:m:n:p:qr:s:u:w:y:z:F:G:H:M:N:PR:S:T:U:L:Z")) != -1) {
     printf("handling optarg %c\n",c);
     switch (c) {
 
@@ -459,6 +460,10 @@ int main(int argc, char **argv)
     case 'p':
       extended_prefix_flag = 1;
       break;
+
+    case 'q':
+      max_rounds = 1;
+      break;
       
     case 'r':
       nb_rb = atoi(optarg);
@@ -838,7 +843,6 @@ int main(int argc, char **argv)
   uint16_t n_rb1 = 75;
   
   uint16_t pdu_bit_map = PUSCH_PDU_BITMAP_PUSCH_DATA; // | PUSCH_PDU_BITMAP_PUSCH_PTRS;
-  uint8_t max_rounds = 4;
   uint8_t crc_status = 0;
 
   unsigned char mod_order = nr_get_Qm_ul(Imcs, mcs_table);