WIP: Replacing buffers, ldpctest passes, free does not work, TODO: implementation into softmodem

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -157,7 +157,9 @@ int test_ldpc(short No_iteration,
   //double code_rate_actual_vec[8] = {0.2, 0.33333, 0.4, 0.5, 0.66667, 0.73333, 0.81481, 0.88};
 
   t_nrLDPC_dec_params decParams;
-
+  t_nrLDPC_procBuf nrLDPC_procBuf;
+  t_nrLDPC_procBuf* p_nrLDPC_procBuf = &nrLDPC_procBuf;
+    
   t_nrLDPC_time_stats decoder_profiler;
   t_nrLDPC_time_stats* p_decoder_profiler =&decoder_profiler ;
 
@@ -210,6 +212,9 @@ int test_ldpc(short No_iteration,
   reset_meas(&decoder_profiler.llr2bit);
   //reset_meas(&decoder_profiler.total);
 
+  // Allocate LDPC decoder buffers
+  p_nrLDPC_procBuf = nrLDPC_init_mem();
+
   for (j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
     for (i=0; i<block_length/8; i++) {
       test_input[j][i]=(unsigned char) rand();
@@ -411,7 +416,7 @@ int test_ldpc(short No_iteration,
       // decoder supports BG2, Z=128 & 256
       //esimated_output=ldpc_decoder(channel_output_fixed, block_length, No_iteration, (double)((float)nom_rate/(float)denom_rate));
       ///nrLDPC_decoder(&decParams, channel_output_fixed, estimated_output, NULL);
-	n_iter = nrLDPC_decoder(&decParams, (int8_t*)channel_output_fixed[j], (int8_t*)estimated_output[j], p_decoder_profiler);
+          n_iter = nrLDPC_decoder(&decParams, (int8_t*)channel_output_fixed[j], (int8_t*)estimated_output[j], p_nrLDPC_procBuf, p_decoder_profiler);
       
 	stop_meas(time_decoder);
       }
@@ -489,6 +494,8 @@ int test_ldpc(short No_iteration,
   //free(channel_output_fixed);
   //free(estimated_output);
 
+  //nrLDPC_free_mem(p_nrLDPC_procBuf);
+  
   print_meas(&time,"ldpc_encoder",NULL,NULL);
   print_meas(time_optim,"ldpc_encoder_optim",NULL,NULL);
   print_meas(&tinput,"ldpc_encoder_optim(input)",NULL,NULL);

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_bnProc.h

@@ -37,12 +37,17 @@
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_bnProcPc(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_bnProcPc(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numBnInBnGroups = p_lut->numBnInBnGroups;
     const uint32_t* lut_startAddrBnGroups = p_lut->startAddrBnGroups;
     const uint16_t* lut_startAddrBnGroupsLlr = p_lut->startAddrBnGroupsLlr;
 
+    int8_t* bnProcBuf    = p_procBuf->bnProcBuf;
+    int8_t* bnProcBufRes = p_procBuf->bnProcBufRes;
+    int8_t* llrRes       = p_procBuf->llrRes;
+    int8_t* llrProcBuf   = p_procBuf->llrProcBuf;
+        
     __m128i* p_bnProcBuf;
     __m256i* p_bnProcBufRes;
     __m128i* p_llrProcBuf;
@@ -1676,7 +1681,7 @@ static inline void nrLDPC_bnProcPc(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     // BN Processing calculating the values to send back to the CNs for next iteration
     // bnProcBufRes contains the sum of all edges to each BN at the start of each group
@@ -1685,6 +1690,10 @@ static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, uint16_t Z)
     const uint32_t* lut_startAddrBnGroups = p_lut->startAddrBnGroups;
     const uint16_t* lut_startAddrBnGroupsLlr = p_lut->startAddrBnGroupsLlr;
 
+    int8_t* bnProcBuf    = p_procBuf->bnProcBuf;
+    int8_t* bnProcBufRes = p_procBuf->bnProcBufRes;
+    int8_t* llrRes       = p_procBuf->llrRes;
+    
     __m256i* p_bnProcBuf;
     __m256i* p_bnProcBufRes;
     __m256i* p_llrRes;

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h

@@ -36,11 +36,14 @@
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -362,11 +365,14 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -858,11 +864,14 @@ static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param Z Lifting size
    \return 32-bit parity check indicator
 */
-static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -1490,11 +1499,14 @@ static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param Z Lifting size
    \return 32-bit parity check indicator
 */
-static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h

@@ -32,6 +32,7 @@
 #define __NR_LDPC_DECODER__H__
 
 #include "nrLDPC_types.h"
+#include "nrLDPC_init_mem.h"
 
 /**
    \brief LDPC decoder
@@ -40,6 +41,6 @@
    \param p_llrOut Output vector
    \param p_profiler LDPC profiler statistics
 */
-int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_llrOut, t_nrLDPC_time_stats* p_profiler);
+int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_llrOut, t_nrLDPC_procBuf* p_procBuf, t_nrLDPC_time_stats* p_profiler);
 
 #endif

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_defs.h

@@ -104,19 +104,19 @@
 
 // Aligned on 32 bytes = 256 bits for AVX2
 /** CN processing buffer */
-static int8_t cnProcBuf   [NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32)));
+//static int8_t cnProcBuf   [NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32)));
 /** Buffer for CN processing results */
-static int8_t cnProcBufRes[NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32)));
+//static int8_t cnProcBufRes[NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32)));
 
 /** BN processing buffer */
-static int8_t bnProcBuf   [NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32)));
+//static int8_t bnProcBuf   [NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32)));
 /** Buffer for BN processing results */
-static int8_t bnProcBufRes[NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32)));
+//static int8_t bnProcBufRes[NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32)));
 
 /** Buffer for LLR results */
-static int8_t llrRes    [NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
+//static int8_t llrRes    [NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
 /** LLR processing buffer */
-static int8_t llrProcBuf[NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
+//static int8_t llrProcBuf[NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
 
 /** Start addresses for the cnProcBuf for each CN group in BG1*/
 static const uint32_t lut_startAddrCnGroups_BG1[NR_LDPC_NUM_CN_GROUPS_BG1] = {0, 1152, 8832, 43392, 61824, 75264, 81408, 88320, 92160};

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init_mem.h

+/*
+ * 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_defs.h"
+#include "nrLDPC_types.h"
+
+#ifndef malloc32_clear
+/**
+   \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;
+}
+#endif
+
+/**
+   \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 procBuf;
+    t_nrLDPC_procBuf* p_procBuf = &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));
+
+    int i;
+    for (i=0;i<10;i++)
+    {
+        printf("p_procBuf->cnProcBuf[%d] = %d\n",i,p_procBuf->cnProcBuf[i]);
+        printf("p_procBuf->cnProcBuf[%d] = %d\n",NR_LDPC_SIZE_CN_PROC_BUF - i - 1,p_procBuf->cnProcBuf[NR_LDPC_SIZE_CN_PROC_BUF - i - 1]);
+    }
+
+    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);
+}
+#endif

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h

@@ -41,13 +41,15 @@
    \param Z Lifting size
    \param BG Base graph
 */
-static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16_t Z, uint8_t BG)
+static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, t_nrLDPC_procBuf* p_procBuf, uint16_t Z, uint8_t BG)
 {
     const uint16_t* lut_llr2llrProcBuf = p_lut->llr2llrProcBuf;
     uint32_t i;
     const uint8_t numBn2CnG1 = p_lut->numBnInBnGroups[0];
     uint32_t colG1 = NR_LDPC_START_COL_PARITY_BG1*Z;
 
+    int8_t* llrProcBuf = p_procBuf->llrProcBuf;
+    
     if (BG == 2)
     {
         colG1 = NR_LDPC_START_COL_PARITY_BG2*Z;
@@ -74,11 +76,13 @@ static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint1
    \param Z Lifting size
    \param BG Base graph
 */
-static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16_t numLLR, uint16_t Z, uint8_t BG)
+static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, t_nrLDPC_procBuf* p_procBuf, uint16_t numLLR, uint16_t Z, uint8_t BG)
 {
     const uint32_t* lut_llr2CnProcBuf = p_lut->llr2CnProcBuf;
     const uint8_t* lut_numEdgesPerBn = p_lut->numEdgesPerBn;
 
+    int8_t* cnProcBuf = p_procBuf->cnProcBuf;
+    
     int8_t curLLR;
     uint8_t numEdges;
     uint32_t i;
@@ -123,12 +127,15 @@ static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf;
     const uint8_t*  lut_numCnInCnGroups = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    int8_t* bnProcBuf    = p_procBuf->bnProcBuf;
+    
     const uint32_t* p_lut_cn2bn;
     int8_t* p_cnProcBufRes;
     uint32_t bitOffsetInGroup;
@@ -245,12 +252,15 @@ static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf;
     const uint8_t*  lut_numCnInCnGroups = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+    int8_t* bnProcBuf    = p_procBuf->bnProcBuf;
+    
     const uint32_t* p_lut_cn2bn;
     int8_t* p_cnProcBufRes;
     uint32_t bitOffsetInGroup;
@@ -418,12 +428,15 @@ static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf;
     const uint8_t*  lut_numCnInCnGroups = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf = p_procBuf->cnProcBuf;
+    int8_t* bnProcBufRes = p_procBuf->bnProcBufRes;
+    
     int8_t* p_cnProcBuf;
     const uint32_t* p_lut_cn2bn;
     uint32_t bitOffsetInGroup;
@@ -543,12 +556,15 @@ static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
-static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
+static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf;
     const uint8_t*  lut_numCnInCnGroups = p_lut->numCnInCnGroups;
     const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
 
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* bnProcBufRes = p_procBuf->bnProcBufRes;
+    
     int8_t* p_cnProcBuf;
     const uint32_t* p_lut_cn2bn;
     uint32_t bitOffsetInGroup;
@@ -720,11 +736,13 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z)
    \param llrOut Pointer to output LLRs
    \param numLLR Number of LLR values
 */
-static inline void nrLDPC_llrRes2llrOut(t_nrLDPC_lut* p_lut, int8_t* llrOut, uint16_t numLLR)
+static inline void nrLDPC_llrRes2llrOut(t_nrLDPC_lut* p_lut, int8_t* llrOut, t_nrLDPC_procBuf* p_procBuf, uint16_t numLLR)
 {
     const uint16_t* lut_llr2llrProcBuf = p_lut->llr2llrProcBuf;
     uint32_t i;
 
+    int8_t* llrRes = p_procBuf->llrRes;
+    
     for (i=0; i<numLLR; i++)
     {
         llrOut[i] = llrRes[lut_llr2llrProcBuf[i]];

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/nrLDPC_debug.h

@@ -87,38 +87,38 @@ static inline void nrLDPC_initFile(const char* fileName)
    \brief Writes data of predefined buffers to file
    \param buffer Enum of buffer name to write
 */
-static inline void nrLDPC_debug_writeBuffer2File(e_nrLDPC_buffers buffer)
+static inline void nrLDPC_debug_writeBuffer2File(e_nrLDPC_buffers buffer, t_nrLDPC_procBuf* p_procBuf)
 {
     switch (buffer)
     {
     case nrLDPC_buffers_LLR_PROC:
     {
-        nrLDPC_writeFile("llrProcBuf.txt", llrProcBuf, NR_LDPC_MAX_NUM_LLR);
+        nrLDPC_writeFile("llrProcBuf.txt", p_procBuf->llrProcBuf, NR_LDPC_MAX_NUM_LLR);
         break;
     }
     case nrLDPC_buffers_CN_PROC:
     {
-        nrLDPC_writeFile("cnProcBuf.txt", cnProcBuf, NR_LDPC_SIZE_CN_PROC_BUF);
+        nrLDPC_writeFile("cnProcBuf.txt", p_procBuf->cnProcBuf, NR_LDPC_SIZE_CN_PROC_BUF);
         break;
     }
     case nrLDPC_buffers_CN_PROC_RES:
     {
-        nrLDPC_writeFile("cnProcBufRes.txt", cnProcBufRes, NR_LDPC_SIZE_CN_PROC_BUF);
+        nrLDPC_writeFile("cnProcBufRes.txt", p_procBuf->cnProcBufRes, NR_LDPC_SIZE_CN_PROC_BUF);
         break;
     }
     case nrLDPC_buffers_BN_PROC:
     {
-        nrLDPC_writeFile("bnProcBuf.txt", bnProcBuf, NR_LDPC_SIZE_BN_PROC_BUF);
+        nrLDPC_writeFile("bnProcBuf.txt", p_procBuf->bnProcBuf, NR_LDPC_SIZE_BN_PROC_BUF);
         break;
     }
     case nrLDPC_buffers_BN_PROC_RES:
     {
-        nrLDPC_writeFile("bnProcBufRes.txt", bnProcBufRes, NR_LDPC_SIZE_BN_PROC_BUF);
+        nrLDPC_writeFile("bnProcBufRes.txt", p_procBuf->bnProcBufRes, NR_LDPC_SIZE_BN_PROC_BUF);
         break;
     }
     case nrLDPC_buffers_LLR_RES:
     {
-        nrLDPC_writeFile("llrRes.txt", llrRes, NR_LDPC_MAX_NUM_LLR);
+        nrLDPC_writeFile("llrRes.txt", p_procBuf->llrRes, NR_LDPC_MAX_NUM_LLR);
         break;
     }
     }

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h

@@ -88,4 +88,16 @@ typedef struct nrLDPC_time_stats {
     time_stats_t total; /**< Statistics for total processing time */
 } t_nrLDPC_time_stats;
 
+/**
+   Structure containing the processing buffers
+ */
+typedef struct nrLDPC_procBuf {
+    int8_t* cnProcBuf; /**< CN processing buffer */
+    int8_t* cnProcBufRes; /**< Buffer for CN processing results */
+    int8_t* bnProcBuf; /**< BN processing buffer */
+    int8_t* bnProcBufRes; /**< Buffer for BN processing results */
+    int8_t* llrRes; /**< Buffer for LLR results */
+    int8_t* llrProcBuf; /**< LLR processing buffer */
+} t_nrLDPC_procBuf;
+
 #endif

openair1/PHY/INIT/nr_init_ue.c

@@ -937,6 +937,9 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
 
   ue->dlsch_MCH[0]  = new_nr_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_LDPC_ITERATIONS_MBSFN,ue->frame_parms.N_RB_DL,0);
 
+  // LDPC processing buffer allocation
+  ue->p_nrLDPC_procBuf[0] = nrLDPC_init_mem();
+  ue->p_nrLDPC_procBuf[1] = nrLDPC_init_mem();  
 }
 
 void phy_init_nr_top(PHY_VARS_NR_UE *ue)

openair1/PHY/defs_nr_UE.h

@@ -158,6 +158,7 @@
 #include "targets/ARCH/COMMON/common_lib.h"
 
 #include "NR_IF_Module.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
 
 /// Context data structure for RX/TX portion of subframe processing
 typedef struct {
@@ -1063,6 +1064,9 @@ typedef struct {
 #endif
   t_nrPolar_params  *nrPolar_params;
 
+  /// LDPC processing buffers for 2 segments in parallel
+  t_nrLDPC_procBuf* p_nrLDPC_procBuf[2];
+
   /// PBCH DMRS sequence
   uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];