feat(ldpc-decoding-module-interface-rework): Add slot encoding to the interface and interface demo

CMakeLists.txt

@@ -867,7 +867,7 @@ add_dependencies(ldpc_cl nrLDPC_decoder_kernels_CL)
 
 set(PHY_NR_ULSCH_DECODING_DEMO_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nr_ulsch_decoding_interface_demo.c
-  ${PHY_LDPC_OPTIM8SEGMULTI_SRC}
+  ${OPENAIR1_DIR}/PHY/CODING/nr_dlsch_encoding_interface_demo.c
 )
 
 set(PHY_NR_CODINGIF
@@ -899,7 +899,6 @@ add_library(coding MODULE ${PHY_TURBOSRC} )
 add_library(dfts MODULE ${OPENAIR1_DIR}/PHY/TOOLS/oai_dfts.c ${OPENAIR1_DIR}/PHY/TOOLS/oai_dfts_neon.c)
 
 add_library(ldpc_slot_demo MODULE ${PHY_NR_ULSCH_DECODING_DEMO_SRC})
-target_link_libraries(ldpc_slot_demo PRIVATE ldpc_gen_HEADERS)
 
 set(PHY_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_common.c

openair1/PHY/CODING/nr_dlsch_encoding_interface_demo.c

+/*
+ * 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.0  (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 PHY/LTE_TRANSPORT/dlsch_coding.c
+* \brief Top-level routines for implementing LDPC-coded (DLSCH) transport channels from 38-212, 15.2
+* \author H.Wang
+* \date 2018
+* \version 0.1
+* \company Eurecom
+* \email:
+* \note
+* \warning
+*/
+
+#include "PHY/defs_gNB.h"
+#include "PHY/CODING/coding_extern.h"
+#include "PHY/CODING/coding_defs.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/CODING/nrLDPC_extern.h"
+#include "PHY/NR_TRANSPORT/nr_transport_proto.h"
+#include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "PHY/NR_TRANSPORT/nr_dlsch.h"
+#include "SCHED_NR/sched_nr.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "common/utils/LOG/log.h"
+#include "common/utils/nr/nr_common.h"
+#include <syscall.h>
+#include <openair2/UTIL/OPT/opt.h>
+
+//#define DEBUG_DLSCH_CODING
+//#define DEBUG_DLSCH_FREE 1
+
+extern ldpc_interface_t ldpc_interface_demo;
+
+static void ldpc8blocks_demo(void *p)
+{
+  encoder_implemparams_t *impp=(encoder_implemparams_t *) p;
+  NR_DL_gNB_HARQ_t *harq = (NR_DL_gNB_HARQ_t *)impp->harq;
+  nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &harq->pdsch_pdu.pdsch_pdu_rel15;
+  uint8_t mod_order = rel15->qamModOrder[0];
+  uint16_t nb_rb = rel15->rbSize;
+  uint8_t nb_symb_sch = rel15->NrOfSymbols;
+  uint16_t length_dmrs = get_num_dmrs(rel15->dlDmrsSymbPos);
+  uint32_t A = rel15->TBSize[0]<<3;
+  uint8_t nb_re_dmrs;
+
+  if (rel15->dmrsConfigType==NFAPI_NR_DMRS_TYPE1)
+    nb_re_dmrs = 6*rel15->numDmrsCdmGrpsNoData;
+  else
+    nb_re_dmrs = 4*rel15->numDmrsCdmGrpsNoData;
+
+  unsigned int G = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, harq->unav_res, mod_order, rel15->nrOfLayers);
+  LOG_D(PHY,"dlsch coding A %d  Kr %d G %d (nb_rb %d, nb_symb_sch %d, nb_re_dmrs %d, length_dmrs %d, mod_order %d)\n",
+        A,impp->K,G, nb_rb,nb_symb_sch,nb_re_dmrs,length_dmrs,(int)mod_order);
+  // nrLDPC_encoder output is in "d"
+  // let's make this interface happy!
+  uint8_t tmp[8][68 * 384]__attribute__((aligned(32)));
+  uint8_t *d[impp->n_segments];
+  for (int rr=impp->macro_num*8, i=0; rr < impp->n_segments && rr < (impp->macro_num+1)*8; rr++,i++ )
+    d[rr] = tmp[i];
+  ldpc_interface_demo.LDPCencoder(harq->c, d, impp);
+  // Compute where to place in output buffer that is concatenation of all segments
+  uint32_t r_offset=0;
+  for (int i=0; i < impp->macro_num*8; i++ )
+     r_offset+=nr_get_E(G, impp->n_segments, mod_order, rel15->nrOfLayers, i);
+  for (int rr=impp->macro_num*8; rr < impp->n_segments && rr < (impp->macro_num+1)*8; rr++ ) {
+    if (impp->F>0) {
+      // writing into positions d[r][k-2Zc] as in clause 5.3.2 step 2) in 38.212
+      memset(&d[rr][impp->K - impp->F - 2 * impp->Zc], NR_NULL, impp->F);
+    }
+
+#ifdef DEBUG_DLSCH_CODING
+    LOG_D(PHY,"rvidx in encoding = %d\n", rel15->rvIndex[0]);
+#endif
+    uint32_t E = nr_get_E(G, impp->n_segments, mod_order, rel15->nrOfLayers, rr);
+    //#ifdef DEBUG_DLSCH_CODING
+    LOG_D(NR_PHY,
+          "Rate Matching, Code segment %d/%d (coded bits (G) %u, E %d, Filler bits %d, Filler offset %d mod_order %d, nb_rb "
+          "%d,nrOfLayer %d)...\n",
+          rr,
+          impp->n_segments,
+          G,
+          E,
+          impp->F,
+          impp->K - impp->F - 2 * impp->Zc,
+          mod_order,
+          nb_rb,
+          rel15->nrOfLayers);
+
+    uint32_t Tbslbrm = rel15->maintenance_parms_v3.tbSizeLbrmBytes;
+
+    uint8_t e[E];
+    bzero (e, E);
+    nr_rate_matching_ldpc(Tbslbrm,
+                          impp->BG,
+                          impp->Zc,
+                          d[rr],
+                          e,
+                          impp->n_segments,
+                          impp->F,
+                          impp->K - impp->F - 2 * impp->Zc,
+                          rel15->rvIndex[0],
+                          E);
+    if (impp->K - impp->F - 2 * impp->Zc > E) {
+      LOG_E(PHY,
+            "dlsch coding A %d  Kr %d G %d (nb_rb %d, nb_symb_sch %d, nb_re_dmrs %d, length_dmrs %d, mod_order %d)\n",
+            A,
+            impp->K,
+            G,
+            nb_rb,
+            nb_symb_sch,
+            nb_re_dmrs,
+            length_dmrs,
+            (int)mod_order);
+
+      LOG_E(NR_PHY,
+            "Rate Matching, Code segment %d/%d (coded bits (G) %u, E %d, Kr %d, Filler bits %d, Filler offset %d mod_order %d, "
+            "nb_rb %d)...\n",
+            rr,
+            impp->n_segments,
+            G,
+            E,
+            impp->K,
+            impp->F,
+            impp->K - impp->F - 2 * impp->Zc,
+            mod_order,
+            nb_rb);
+    }
+#ifdef DEBUG_DLSCH_CODING
+
+    for (int i =0; i<16; i++)
+      printf("output ratematching e[%d]= %d r_offset %u\n", i,e[i], r_offset);
+
+#endif
+    nr_interleaving_ldpc(E,
+                         mod_order,
+                         e,
+                         impp->output+r_offset);
+#ifdef DEBUG_DLSCH_CODING
+
+    for (int i =0; i<16; i++)
+      printf("output interleaving f[%d]= %d r_offset %u\n", i,impp->output[i+r_offset], r_offset);
+
+    if (r==impp->n_segments-1)
+      write_output("enc_output.m","enc",impp->output,G,1,4);
+
+#endif
+    r_offset += E;
+  }
+}
+
+static int nr_dlsch_encoding_demo(PHY_VARS_gNB *gNB,
+                      int frame,
+                      uint8_t slot,
+                      NR_DL_gNB_HARQ_t *harq,
+                      NR_DL_FRAME_PARMS *frame_parms,
+                      unsigned char *output,
+                      time_stats_t *tinput,
+                      time_stats_t *tprep,
+                      time_stats_t *tparity,
+                      time_stats_t *toutput,
+                      time_stats_t *dlsch_rate_matching_stats,
+                      time_stats_t *dlsch_interleaving_stats,
+                      time_stats_t *dlsch_segmentation_stats)
+{
+  encoder_implemparams_t impp;
+  impp.output=output;
+  unsigned int crc=1;
+  nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &harq->pdsch_pdu.pdsch_pdu_rel15;
+  impp.Zc = harq->Z;
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_IN);
+  uint32_t A = rel15->TBSize[0]<<3;
+  unsigned char *a=harq->pdu;
+  if (rel15->rnti != SI_RNTI)
+    trace_NRpdu(DIRECTION_DOWNLINK, a, rel15->TBSize[0], WS_C_RNTI, rel15->rnti, frame, slot,0, 0);
+
+  NR_gNB_PHY_STATS_t *phy_stats = NULL;
+  if (rel15->rnti != 0xFFFF)
+    phy_stats = get_phy_stats(gNB, rel15->rnti);
+
+  if (phy_stats) {
+    phy_stats->frame = frame;
+    phy_stats->dlsch_stats.total_bytes_tx += rel15->TBSize[0];
+    phy_stats->dlsch_stats.current_RI = rel15->nrOfLayers;
+    phy_stats->dlsch_stats.current_Qm = rel15->qamModOrder[0];
+  }
+
+  int max_bytes = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*rel15->nrOfLayers*1056;
+  int B;
+  if (A > NR_MAX_PDSCH_TBS) {
+    // Add 24-bit crc (polynomial A) to payload
+    crc = crc24a(a,A)>>8;
+    a[A>>3] = ((uint8_t *)&crc)[2];
+    a[1+(A>>3)] = ((uint8_t *)&crc)[1];
+    a[2+(A>>3)] = ((uint8_t *)&crc)[0];
+    //printf("CRC %x (A %d)\n",crc,A);
+    //printf("a0 %d a1 %d a2 %d\n", a[A>>3], a[1+(A>>3)], a[2+(A>>3)]);
+    B = A + 24;
+    //    harq->b = a;
+    AssertFatal((A / 8) + 4 <= max_bytes,
+                "A %d is too big (A/8+4 = %d > %d)\n",
+                A,
+                (A / 8) + 4,
+                max_bytes);
+    memcpy(harq->b, a, (A / 8) + 4); // why is this +4 if the CRC is only 3 bytes?
+  } else {
+    // Add 16-bit crc (polynomial A) to payload
+    crc = crc16(a,A)>>16;
+    a[A>>3] = ((uint8_t *)&crc)[1];
+    a[1+(A>>3)] = ((uint8_t *)&crc)[0];
+    //printf("CRC %x (A %d)\n",crc,A);
+    //printf("a0 %d a1 %d \n", a[A>>3], a[1+(A>>3)]);
+    B = A + 16;
+    //    harq->b = a;
+    AssertFatal((A / 8) + 3 <= max_bytes,
+                "A %d is too big (A/8+3 = %d > %d)\n",
+                A,
+                (A / 8) + 3,
+                max_bytes);
+    memcpy(harq->b, a, (A / 8) + 3); // using 3 bytes to mimic the case of 24 bit crc
+  }
+
+  impp.BG = rel15->maintenance_parms_v3.ldpcBaseGraph;
+
+  start_meas(dlsch_segmentation_stats);
+  impp.Kb = nr_segmentation(harq->b, harq->c, B, &impp.n_segments, &impp.K, &impp.Zc, &impp.F, impp.BG);
+  stop_meas(dlsch_segmentation_stats);
+
+  if (impp.n_segments>MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*rel15->nrOfLayers) {
+    LOG_E(PHY, "nr_segmentation.c: too many segments %d, B %d\n", impp.n_segments, B);
+    return(-1);
+  }
+  for (int r=0; r<impp.n_segments; r++) {
+    //d_tmp[r] = &harq->d[r][0];
+    //channel_input[r] = &harq->d[r][0];
+#ifdef DEBUG_DLSCH_CODING
+    LOG_D(PHY,"Encoder: B %d F %d \n",harq->B, impp.F);
+    LOG_D(PHY,"start ldpc encoder segment %d/%d\n",r,impp.n_segments);
+    LOG_D(PHY,"input %d %d %d %d %d \n", harq->c[r][0], harq->c[r][1], harq->c[r][2],harq->c[r][3], harq->c[r][4]);
+
+    for (int cnt =0 ; cnt < 22*(*impp.Zc)/8; cnt ++) {
+      LOG_D(PHY,"%d ", harq->c[r][cnt]);
+    }
+
+    LOG_D(PHY,"\n");
+#endif
+    //ldpc_encoder_orig((unsigned char*)harq->c[r],harq->d[r],*Zc,Kb,Kr,BG,0);
+    //ldpc_encoder_optim((unsigned char*)harq->c[r],(unsigned char*)&harq->d[r][0],*Zc,Kb,Kr,BG,NULL,NULL,NULL,NULL);
+  }
+
+  impp.tprep = tprep;
+  impp.tinput = tinput;
+  impp.tparity = tparity;
+  impp.toutput = toutput;
+  impp.harq = harq;
+  notifiedFIFO_t nf;
+  initNotifiedFIFO(&nf);
+  int nbJobs = 0;
+  for (int j = 0; j < (impp.n_segments / 8 + ((impp.n_segments & 7) == 0 ? 0 : 1)); j++) {
+    notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(impp), j, &nf, ldpc8blocks_demo);
+    encoder_implemparams_t *perJobImpp = (encoder_implemparams_t *)NotifiedFifoData(req);
+    *perJobImpp = impp;
+    perJobImpp->macro_num = j;
+    pushTpool(&gNB->threadPool, req);
+    nbJobs++;
+  }
+  while (nbJobs) {
+    notifiedFIFO_elt_t *req = pullTpool(&nf, &gNB->threadPool);
+    if (req == NULL)
+      break; // Tpool has been stopped
+    delNotifiedFIFO_elt(req);
+    nbJobs--;
+  }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
+  return 0;
+}
+
+int nr_ulsch_decoding_encoder(PHY_VARS_gNB *gNB,
+                              processingData_L1tx_t *msgTx,
+                              int frame,
+                              uint8_t slot,
+                              NR_DL_FRAME_PARMS *frame_parms,
+                              unsigned char **output,
+                              time_stats_t *tinput,
+                              time_stats_t *tprep,
+                              time_stats_t *tparity,
+                              time_stats_t *toutput,
+                              time_stats_t *dlsch_rate_matching_stats,
+                              time_stats_t *dlsch_interleaving_stats,
+                              time_stats_t *dlsch_segmentation_stats)
+{
+
+  int nbEncode = 0;
+  for (int dlsch_id = 0; dlsch_id < msgTx->num_pdsch_slot; dlsch_id++) {
+    NR_gNB_DLSCH_t *dlsch = msgTx->dlsch[dlsch_id];
+
+    NR_DL_gNB_HARQ_t *harq = &dlsch->harq_process;
+    nbEncode += nr_dlsch_encoding_demo(gNB,
+                                  frame,
+                                  slot,
+                                  harq,
+                                  frame_parms,
+                                  output[dlsch_id],
+                                  tinput,
+                                  tprep,
+                                  tparity,
+                                  toutput,
+                                  dlsch_rate_matching_stats,
+                                  dlsch_interleaving_stats,
+                                  dlsch_segmentation_stats);
+  }
+
+  return nbEncode;
+
+}

openair1/PHY/CODING/nr_ulsch_decoding_interface.h

@@ -36,10 +36,26 @@ typedef int32_t(nr_ulsch_decoding_shutdown_t)(void);
  */
 typedef int32_t(nr_ulsch_decoding_decoder_t)(PHY_VARS_gNB *gNB, NR_DL_FRAME_PARMS *frame_parms, int frame_rx, int slot_rx, uint32_t *G);
 
+typedef int32_t(nr_ulsch_decoding_encoder_t)
+  (PHY_VARS_gNB *gNB,
+   processingData_L1tx_t *msgTx,
+   int frame_tx,
+   uint8_t slot_tx,
+   NR_DL_FRAME_PARMS* frame_parms,
+   unsigned char ** output,
+   time_stats_t *tinput,
+   time_stats_t *tprep,
+   time_stats_t *tparity,
+   time_stats_t *toutput,
+   time_stats_t *dlsch_rate_matching_stats,
+   time_stats_t *dlsch_interleaving_stats,
+   time_stats_t *dlsch_segmentation_stats);
+
 typedef struct nr_ulsch_decoding_interface_s {
   nr_ulsch_decoding_init_t *nr_ulsch_decoding_init;
   nr_ulsch_decoding_shutdown_t *nr_ulsch_decoding_shutdown;
   nr_ulsch_decoding_decoder_t *nr_ulsch_decoding_decoder;
+  nr_ulsch_decoding_encoder_t *nr_ulsch_decoding_encoder;
 } nr_ulsch_decoding_interface_t;
 
 int load_nr_ulsch_decoding_interface(char *version, nr_ulsch_decoding_interface_t *interface);

openair1/PHY/CODING/nr_ulsch_decoding_interface_demo.c

@@ -63,14 +63,10 @@
 #include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h"
 #include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h"
 
-int32_t LDPCdecoder(t_nrLDPC_dec_params* p_decParams,
-                    uint8_t harq_pid,
-                    uint8_t ulsch_id,
-                    uint8_t C,
-                    int8_t* p_llr,
-                    int8_t* p_out,
-                    t_nrLDPC_time_stats* p_profiler,
-                    decode_abort_t* ab);
+#define DEMO_LDPCLIB_SUFFIX ""
+
+// Global var to limit the rework of the dirty legacy code
+ldpc_interface_t ldpc_interface_demo;
 
 static void nr_processULSegment_demo(void *arg)
 {
@@ -169,7 +165,7 @@ static void nr_processULSegment_demo(void *arg)
 
   ////////////////////////////////// pl =====> llrProcBuf //////////////////////////////////
   rdata->decodeIterations =
-      LDPCdecoder(p_decoderParms, 0, 0, 0, l, llrProcBuf, p_procTime, &ulsch_harq->abort_decode);
+      ldpc_interface_demo.LDPCdecoder(p_decoderParms, 0, 0, 0, l, llrProcBuf, p_procTime, &ulsch_harq->abort_decode);
 
   if (rdata->decodeIterations <= p_decoderParms->numMaxIter)
     memcpy(ulsch_harq->c[r],llrProcBuf,  Kr>>3);
@@ -326,12 +322,16 @@ int nr_ulsch_decoding_demo(PHY_VARS_gNB *phy_vars_gNB,
 
 int32_t nr_ulsch_decoding_init(void){
 
+  load_LDPClib(DEMO_LDPCLIB_SUFFIX, &ldpc_interface_demo);
+
   return 0;
 
 }
 
 int32_t nr_ulsch_decoding_shutdown(void){
 
+  free_LDPClib(&ldpc_interface_demo);
+
   return 0;
 
 }

openair1/PHY/CODING/nr_ulsch_decoding_interface_load.c

@@ -56,7 +56,8 @@ int load_nr_ulsch_decoding_interface(char *version, nr_ulsch_decoding_interface_
   /* function description array, to be used when loading the encoding/decoding shared lib */
   loader_shlibfunc_t shlib_fdesc[] = {{.fname = "nr_ulsch_decoding_init"},
                                       {.fname = "nr_ulsch_decoding_shutdown"},
-                                      {.fname = "nr_ulsch_decoding_decoder"}};
+                                      {.fname = "nr_ulsch_decoding_decoder"},
+                                      {.fname = "nr_ulsch_decoding_encoder"}};
   int ret;
   ret = load_module_version_shlib(libname, version, shlib_fdesc, sizeofArray(shlib_fdesc), NULL);
   if(ret < 0){
@@ -66,6 +67,7 @@ int load_nr_ulsch_decoding_interface(char *version, nr_ulsch_decoding_interface_
   itf->nr_ulsch_decoding_init = (nr_ulsch_decoding_init_t *)shlib_fdesc[0].fptr;
   itf->nr_ulsch_decoding_shutdown = (nr_ulsch_decoding_shutdown_t *)shlib_fdesc[1].fptr;
   itf->nr_ulsch_decoding_decoder = (nr_ulsch_decoding_decoder_t *)shlib_fdesc[2].fptr;
+  itf->nr_ulsch_decoding_encoder = (nr_ulsch_decoding_encoder_t *)shlib_fdesc[3].fptr;
 
   AssertFatal(itf->nr_ulsch_decoding_init() == 0, "error starting LDPC library %s %s\n", libname, version);
 

openair1/PHY/INIT/nr_init.c

@@ -137,13 +137,18 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 
   gNB->nr_ulsch_decoding_interface_flag = 0;
   int ret_loader = load_nr_ulsch_decoding_interface(NULL, &nr_ulsch_decoding_interface);
-  if(ret_loader >= 0)
+  if (ret_loader >= 0) {
     gNB->nr_ulsch_decoding_interface_flag = 1;
-
+    if (gNB->ldpc_offload_flag)
+      load_LDPClib("_t2", &ldpc_interface_offload);
+    else
+      load_LDPClib("", &ldpc_interface);
+  } else {
     if (gNB->ldpc_offload_flag)
       load_LDPClib("_t2", &ldpc_interface_offload);
     else
       load_LDPClib(NULL, &ldpc_interface);
+  }
 
   pthread_mutex_init(&gNB->UL_INFO.crc_rx_mutex, NULL);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -33,6 +33,7 @@
 #include "nr_dlsch.h"
 #include "nr_dci.h"
 #include "nr_sch_dmrs.h"
+#include "PHY/CODING/nr_ulsch_decoding_interface.h"
 #include "PHY/MODULATION/nr_modulation.h"
 #include "PHY/NR_REFSIG/dmrs_nr.h"
 #include "PHY/NR_REFSIG/ptrs_nr.h"
@@ -64,6 +65,9 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
   time_stats_t *dlsch_interleaving_stats=&gNB->dlsch_interleaving_stats;
   time_stats_t *dlsch_segmentation_stats=&gNB->dlsch_segmentation_stats;
 
+  unsigned char **output = calloc(msgTx->num_pdsch_slot, sizeof(unsigned char *));
+  int slot_encoding_done = 0;
+
   for (int dlsch_id=0; dlsch_id<msgTx->num_pdsch_slot; dlsch_id++) {
     NR_gNB_DLSCH_t *dlsch = msgTx->dlsch[dlsch_id];
 
@@ -104,18 +108,52 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
     }
     harq->unav_res = ptrsSymbPerSlot * n_ptrs;
 
+    if(slot_encoding_done)
+      goto after_encoding;
+
     /// CRC, coding, interleaving and rate matching
     AssertFatal(harq->pdu!=NULL,"harq->pdu is null\n");
-    unsigned char output[rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers] __attribute__((aligned(64)));
-    bzero(output,rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers);
+    int ret_memalign = posix_memalign((void **)&output[dlsch_id], 64, sizeof(unsigned char) * rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers);
+    if(ret_memalign){
+      if(gNB->nr_ulsch_decoding_interface_flag)
+        for(int i = 0; i < dlsch_id; i++)
+          free(output[i]);
+      return;
+    }
+    bzero(output[dlsch_id],rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers);
+
+    if(gNB->nr_ulsch_decoding_interface_flag){
+      if(dlsch_id == msgTx->num_pdsch_slot-1){
         start_meas(dlsch_encoding_stats);
+        if (nr_ulsch_decoding_interface.nr_ulsch_decoding_encoder(gNB,
+                                                                  msgTx,
+                                                                  frame,
+                                                                  slot,
+                                                                  frame_parms,
+                                                                  output,
+                                                                  tinput,
+                                                                  tprep,
+                                                                  tparity,
+                                                                  toutput,
+                                                                  dlsch_rate_matching_stats,
+                                                                  dlsch_interleaving_stats,
+                                                                  dlsch_segmentation_stats) == -1) {
+          return;
+        }
+        stop_meas(dlsch_encoding_stats);
+        dlsch_id = -1;
+        slot_encoding_done = 1;
+      }
+      continue;
+    }
 
+    start_meas(dlsch_encoding_stats);
     if (nr_dlsch_encoding(gNB,
                           frame,
                           slot,
                           harq,
                           frame_parms,
-                          output,
+                          output[dlsch_id],
                           tinput,
                           tprep,
                           tparity,
@@ -125,6 +163,8 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
                           dlsch_segmentation_stats) == -1)
       return;
     stop_meas(dlsch_encoding_stats);
+
+after_encoding:
 #ifdef DEBUG_DLSCH
     printf("PDSCH encoding:\nPayload:\n");
     for (int i=0; i<harq->B>>7; i++) {
@@ -135,14 +175,14 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
     printf("\nEncoded payload:\n");
     for (int i=0; i<encoded_length>>3; i++) {
       for (int j=0; j<8; j++)
-	printf("%d", output[(i<<3)+j]);
+	printf("%d", output[dlsch_id][(i<<3)+j]);
       printf("\t");
     }
     printf("\n");
 #endif
 
     if (IS_SOFTMODEM_DLSIM)
-      memcpy(harq->f, output, encoded_length);
+      memcpy(harq->f, output[dlsch_id], encoded_length);
 
     c16_t mod_symbs[rel15->NrOfCodewords][encoded_length];
     for (int codeWord = 0; codeWord < rel15->NrOfCodewords; codeWord++) {
@@ -151,7 +191,9 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
       uint32_t scrambled_output[(encoded_length>>5)+4]; // modulator acces by 4 bytes in some cases
       memset(scrambled_output, 0, sizeof(scrambled_output));
       if ( encoded_length > rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers) abort();
-      nr_pdsch_codeword_scrambling(output, encoded_length, codeWord, rel15->dataScramblingId, rel15->rnti, scrambled_output);
+      nr_pdsch_codeword_scrambling(output[dlsch_id], encoded_length, codeWord, rel15->dataScramblingId, rel15->rnti, scrambled_output);
+
+      free(output[dlsch_id]);
 
 #ifdef DEBUG_DLSCH
       printf("PDSCH scrambling:\n");
@@ -589,6 +631,9 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
       LOG_D(PHY,"beam index for PDSCH allocation already taken\n");
     }
   }// dlsch loop
+
+  free(output);
+
 }
 
 void dump_pdsch_stats(FILE *fd,PHY_VARS_gNB *gNB) {

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -1310,6 +1310,9 @@ int main(int argc, char **argv)
   if (gNB->ldpc_offload_flag)
     free_LDPClib(&ldpc_interface_offload);
 
+  if (gNB->nr_ulsch_decoding_interface_flag)
+    free_nr_ulsch_decoding_interface(&nr_ulsch_decoding_interface);
+
   if (output_fd)
     fclose(output_fd);