dirty commit for providing source of mistaken amduprofile test

CMakeLists.txt

@@ -865,10 +865,19 @@ add_library(ldpc_cl MODULE ${PHY_LDPC_CL_SRC} )
 target_link_libraries(ldpc_cl OpenCL)
 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
+  ${OPENAIR1_DIR}/PHY/CODING/nr_dlsch_encoding_interface_demo.c
+)
+
 set(PHY_NR_CODINGIF
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_load.c
 )
 
+set(PHY_NR_ULSCH_DECODINGIF
+  ${OPENAIR1_DIR}/PHY/CODING/nr_ulsch_decoding_interface_load.c
+)
+
 ##############################################
 # Base CUDA setting
 ##############################################
@@ -889,6 +898,7 @@ 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})
 
 set(PHY_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_common.c
@@ -1078,6 +1088,7 @@ set(PHY_SRC_UE
   ${PHY_POLARSRC}
   ${PHY_SMALLBLOCKSRC}
   ${PHY_NR_CODINGIF}
+  ${PHY_NR_ULSCH_DECODINGIF}
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/pucch_rx.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/srs_rx.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_uci_tools_common.c
@@ -2092,7 +2103,7 @@ if(E2_AGENT)
 endif()
 
 
-add_dependencies(nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc)
+add_dependencies(nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc ldpc_slot_demo)
 
 if (ENABLE_LDPC_T2)
   add_dependencies(nr-softmodem ldpc_t2)
@@ -2329,6 +2340,7 @@ add_executable(nr_ulsim
 if (ENABLE_LDPC_T2)
   add_dependencies(nr_ulsim ldpc_t2)
 endif()
+add_dependencies(nr_ulsim ldpc_slot_demo)
 
 target_link_libraries(nr_ulsim PRIVATE
   -Wl,--start-group UTIL SIMU SIMU_ETH PHY_COMMON PHY_NR_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_UE_NR MAC_NR_COMMON nr_rrc CONFIG_LIB L2_NR HASHTABLE x2ap SECURITY ngap -lz -Wl,--end-group
@@ -2395,7 +2407,7 @@ if (${T_TRACER})
         PHY_COMMON PHY PHY_UE PHY_NR PHY_NR_COMMON PHY_NR_UE PHY_RU PHY_MEX
         L2 L2_LTE L2_NR L2_LTE_NR L2_UE NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON MAC_UE_NR ngap
         CN_UTILS GTPV1U SCTP_CLIENT MME_APP LIB_NAS_UE NB_IoT SIMU SIMU_ETH OPENAIR0_LIB
-        ldpc_orig ldpc_optim ldpc_optim8seg ldpc_t2 ldpc_cl ldpc_cuda ldpc dfts config_internals)
+        ldpc_orig ldpc_optim ldpc_optim8seg ldpc_t2 ldpc_cl ldpc_cuda ldpc ldpc_slot_demo dfts config_internals)
     if (TARGET ${i})
       add_dependencies(${i} generate_T)
     endif()

openair1/PHY/CODING/DOC/LDPCImplementation.md

@@ -1,7 +1,12 @@
 # LDPC coder/decoder implementation
-The LDPC coder and decoder are implemented in a shared library, dynamically loaded at run-time using the [oai shared library loader](file://../../../../common/utils/DOC/loader.md). The code loading the LDPC library is in [nrLDPC_load.c](file://../nrLDPC_load.c), in function `load_nrLDPClib`, which must be called at init time.
+The LDPC coder and decoder are implemented in a shared library, dynamically loaded at run-time using the [oai shared library loader](file://../../../../common/utils/DOC/loader.md).
+Two types of library are available with two different interfaces. There are libraries implementing the coder and decoder of code segments and libraries implementing the decoder of slots.
 
-## Selecting the LDPC library at run time
+## LDPC segment coder/decoder
+The interface of the library is defined in [nrLDPC_defs.h](file://../nrLDPC_defs.h).
+The code loading the LDPC library is in [nrLDPC_load.c](file://../nrLDPC_load.c), in function `load_nrLDPClib`, which must be called at init time.
+
+### Selecting the LDPC library at run time
 
 By default the function `int load_nrLDPClib(void)` looks for `libldpc.so`, this default behavior can be changed using the oai loader configuration options in the configuration file or from the command line as shown below:
 
@@ -196,4 +201,68 @@ Libraries implementing the LDPC algorithms must be named `libldpc<_version>.so`,
 
 `libldpc_cl.so`is under development.
 
+## LDPC slot decoder
+The interface of the library is defined in [nr_ulsch_decoding_interface.h](file://../nr_ulsch_decoding_interface.h).
+The code loading the LDPC library is in [nr_ulsch_decoding_interface_load.c](file://../nr_ulsch_decoding_interface_load.c), in function `load_nr_ulsch_decoding_interface`, which must be called at init time.
+
+### Selecting the LDPC library at run time
+
+By default the function `int load_nr_ulsch_decoding_interface(void)` looks for `libldpc.so`.\
+If `libldpc.so` does not implement the LDPC slot decoder interface then the loader just fails which allows to fallback to the code segment decoding interface.\
+This default behavior can be changed using the oai loader configuration options in the configuration file or from the command line as shown below:
+
+#### Examples of ldpc shared lib selection when running nr softmodem's:
+
+loading `libldpc_slot_demo.so` instead of `libldpc.so`:
+
+```
+./nr-softmodem -O libconfig:gnb.band78.tm1.106PRB.usrpx300.conf:dbgl5  --loader.ldpc.shlibversion _slot_demo
+.......................
+[CONFIG] loader.ldpc.shlibversion set to default value ""
+[LIBCONFIG] loader.ldpc: 2/2 parameters successfully set, (1 to default value)
+[CONFIG] shlibversion set to  _slot_demo from command line
+[CONFIG] loader.ldpc 1 options set from command line
+shlib_path libldpc_slot_demo.so
+[LOADER] library libldpc_slot_demo.so successfully loaded
+........................
+```
+
+loading `libldpc_slot_t2.so` instead of `libldpc.so`:
+
+`make ldpc_slot_t2`
+
+This command creates the `libldpc_slot_t2.so` shared library.
+
+```
+Building C object CMakeFiles/ldpc_slot_t2.dir/openair1/PHY/CODING/nrLDPC_decoder/nr_ulsch_decoding_t2.c.o
+Linking C shared module libldpc_slot_t2.so
+```
+
+At runtime, to successfully use the T2 board, you need to install vendor specific drivers and tools.
+
+`./nr-softmodem -O  libconfig:gnb.band78.sa.fr1.106PRB.usrpb210.conf:dbgl5 --rfsim --rfsimulator.serveraddr server  --sa --log_config.gtpu_log_level info  --loader.ldpc.shlibversion _slot_t2`
+
+``` 
+
+.......................
+[CONFIG] loader.ldpc.shlibversion set to default value ""
+[LIBCONFIG] loader.ldpc: 2/2 parameters successfully set, (1 to default value)
+[CONFIG] shlibversion set to  _slot_t2 from command line
+[CONFIG] loader.ldpc 1 options set from command line
+shlib_path libldpc_slot_t2.so
+[LOADER] library libldpc_slot_t2.so successfully loaded
+........................
+```
+
+#### Examples of ldpc shared lib selection when running ldpctest:
+
+Slot decoding libraries cannot be used within ldpctest.
+
+### LDPC libraries
+Libraries implementing the slotwise LDPC decoding must be named `libldpc<_version>.so`, in addition of the code segment decoding interface that is necessary for encoding, they must implement three functions: `nr_ulsch_decoding_init`, `nr_ulsch_decoding_shutdown` and `nr_ulsch_decoding_decoder`. The prototypes for these functions is defined in [nr_ulsch_decoding_interface.h](file://../nr_ulsch_decoding_interface.h).
+
+`libldpc_slot_demo.so`has been tested with the `nr_ulsim` and `nr-softmodem` executables.
+
+`libnr_slot_t2.so`is under development.
+
 [oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)

openair1/PHY/CODING/nr_dlsch_encoding_interface_demo.c

@@ -0,0 +1,333 @@
+/*
+ * 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

@@ -0,0 +1,68 @@
+/*
+ * 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
+ */
+
+#include "PHY/defs_gNB.h"
+
+#ifndef __NR_ULSCH_DECODING_INTERFACE__H__
+#define __NR_ULSCH_DECODING_INTERFACE__H__
+
+typedef int32_t(nr_ulsch_decoding_init_t)(void);
+typedef int32_t(nr_ulsch_decoding_shutdown_t)(void);
+/**
+ * \brief slot decoding function interface
+ * \param gNB PHY layers variables of gNB
+ * \param frame_parms informations on the frame
+ * \param frame_rx RX frame index
+ * \param slot_rx RX slot index
+ * \param G arrays of G
+ */
+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);
+int free_nr_ulsch_decoding_interface(nr_ulsch_decoding_interface_t *interface);
+
+//TODO replace the global structure below
+// Global var to limit the rework of the dirty legacy code
+extern nr_ulsch_decoding_interface_t nr_ulsch_decoding_interface;
+
+#endif

openair1/PHY/CODING/nr_ulsch_decoding_interface_demo.c

@@ -0,0 +1,354 @@
+/*
+ * 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/NR_TRANSPORT/nr_ulsch_decoding.c
+* \brief Top-level routines for decoding  LDPC (ULSCH) transport channels from 38.212, V15.4.0 2018-12
+* \author Ahmed Hussein
+* \date 2019
+* \version 0.1
+* \company Fraunhofer IIS
+* \email: ahmed.hussein@iis.fraunhofer.de
+* \note
+* \warning
+*/
+
+
+// [from gNB coding]
+#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_common_proto.h"
+#include "PHY/NR_TRANSPORT/nr_transport_proto.h"
+#include "PHY/NR_TRANSPORT/nr_ulsch.h"
+#include "PHY/NR_TRANSPORT/nr_dlsch.h"
+#include "SCHED_NR/sched_nr.h"
+#include "SCHED_NR/fapi_nr_l1.h"
+#include "defs.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "common/utils/LOG/log.h"
+#include <syscall.h>
+//#define DEBUG_ULSCH_DECODING
+//#define gNB_DEBUG_TRACE
+
+#define OAI_UL_LDPC_MAX_NUM_LLR 27000//26112 // NR_LDPC_NCOL_BG1*NR_LDPC_ZMAX = 68*384
+//#define DEBUG_CRC
+#ifdef DEBUG_CRC
+#define PRINT_CRC_CHECK(a) a
+#else
+#define PRINT_CRC_CHECK(a)
+#endif
+
+//extern double cpuf;
+
+#include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h"
+#include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h"
+
+#define DEMO_LDPCLIB_SUFFIX "_optim8segmulti"
+
+// Global var to limit the rework of the dirty legacy code
+ldpc_interface_t ldpc_interface_demo;
+
+static void nr_processULSegment_demo(void *arg)
+{
+  ldpcDecode_t *rdata = (ldpcDecode_t *)arg;
+  NR_UL_gNB_HARQ_t *ulsch_harq = rdata->ulsch_harq;
+  t_nrLDPC_dec_params *p_decoderParms = &rdata->decoderParms;
+  const int Kr = ulsch_harq->K;
+  const int Kr_bytes = Kr >> 3;
+  const int K_bits_F = Kr - ulsch_harq->F;
+  const int r = rdata->segment_r;
+  const int A = rdata->A;
+  const int E = rdata->E;
+  const int Qm = rdata->Qm;
+  const int rv_index = rdata->rv_index;
+  const int r_offset = rdata->r_offset;
+  const uint8_t kc = rdata->Kc;
+  short *ulsch_llr = rdata->ulsch_llr;
+  const int max_ldpc_iterations = p_decoderParms->numMaxIter;
+  int8_t llrProcBuf[OAI_UL_LDPC_MAX_NUM_LLR] __attribute__((aligned(32)));
+
+  t_nrLDPC_time_stats procTime = {0};
+  t_nrLDPC_time_stats *p_procTime = &procTime;
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////// nr_deinterleaving_ldpc ///////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////
+
+  //////////////////////////// ulsch_llr =====> ulsch_harq->e //////////////////////////////
+
+  /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+  int16_t harq_e[E];
+
+  nr_deinterleaving_ldpc(E, Qm, harq_e, ulsch_llr + r_offset);
+
+  // for (int i =0; i<16; i++)
+  //          printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,ulsch_harq->w[r][i], r_offset);
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////// nr_rate_matching_ldpc_rx ////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////
+
+  ///////////////////////// ulsch_harq->e =====> ulsch_harq->d /////////////////////////
+
+
+  if (nr_rate_matching_ldpc_rx(rdata->tbslbrm,
+                               p_decoderParms->BG,
+                               p_decoderParms->Z,
+                               ulsch_harq->d[r],
+                               harq_e,
+                               ulsch_harq->C,
+                               rv_index,
+                               ulsch_harq->d_to_be_cleared[r],
+                               E,
+                               ulsch_harq->F,
+                               Kr - ulsch_harq->F - 2 * (p_decoderParms->Z))
+      == -1) {
+
+    LOG_E(PHY, "ulsch_decoding.c: Problem in rate_matching\n");
+    rdata->decodeIterations = max_ldpc_iterations + 1;
+    return;
+  }
+
+  ulsch_harq->d_to_be_cleared[r] = false;
+
+  memset(ulsch_harq->c[r], 0, Kr_bytes);
+  p_decoderParms->crc_type = crcType(ulsch_harq->C, A);
+  p_decoderParms->E = lenWithCrc(ulsch_harq->C, A);
+  // start_meas(&phy_vars_gNB->ulsch_ldpc_decoding_stats);
+
+  // set first 2*Z_c bits to zeros
+
+  int16_t z[68 * 384 + 16] __attribute__((aligned(16)));
+
+  memset(z, 0, 2 * ulsch_harq->Z * sizeof(*z));
+  // set Filler bits
+  memset(z + K_bits_F, 127, ulsch_harq->F * sizeof(*z));
+  // Move coded bits before filler bits
+  memcpy(z + 2 * ulsch_harq->Z, ulsch_harq->d[r], (K_bits_F - 2 * ulsch_harq->Z) * sizeof(*z));
+  // skip filler bits
+  memcpy(z + Kr, ulsch_harq->d[r] + (Kr - 2 * ulsch_harq->Z), (kc * ulsch_harq->Z - Kr) * sizeof(*z));
+  // Saturate coded bits before decoding into 8 bits values
+  simde__m128i *pv = (simde__m128i *)&z;
+  int8_t l[68 * 384 + 16] __attribute__((aligned(16)));
+  simde__m128i *pl = (simde__m128i *)&l;
+  for (int i = 0, j = 0; j < ((kc * ulsch_harq->Z) >> 4) + 1; i += 2, j++) {
+    pl[j] = simde_mm_packs_epi16(pv[i], pv[i + 1]);
+  }
+  //////////////////////////////////////////////////////////////////////////////////////////
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////// nrLDPC_decoder /////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////// pl =====> llrProcBuf //////////////////////////////////
+  rdata->decodeIterations =
+      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);
+}
+
+int nr_ulsch_decoding_demo(PHY_VARS_gNB *phy_vars_gNB,
+                      uint8_t ULSCH_id,
+                      short *ulsch_llr,
+                      NR_DL_FRAME_PARMS *frame_parms,
+                      nfapi_nr_pusch_pdu_t *pusch_pdu,
+                      uint32_t frame,
+                      uint8_t nr_tti_rx,
+                      uint8_t harq_pid,
+                      uint32_t G)
+{
+  if (!ulsch_llr) {
+    LOG_E(PHY, "ulsch_decoding.c: NULL ulsch_llr pointer\n");
+    return -1;
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING, 1);
+
+  NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
+  NR_gNB_PUSCH *pusch = &phy_vars_gNB->pusch_vars[ULSCH_id];
+  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
+
+  if (!harq_process) {
+    LOG_E(PHY, "ulsch_decoding.c: NULL harq_process pointer\n");
+    return -1;
+  }
+
+  // ------------------------------------------------------------------
+  const uint16_t nb_rb = pusch_pdu->rb_size;
+  const uint8_t Qm = pusch_pdu->qam_mod_order;
+  const uint8_t mcs = pusch_pdu->mcs_index;
+  const uint8_t n_layers = pusch_pdu->nrOfLayers;
+  // ------------------------------------------------------------------
+
+  harq_process->processedSegments = 0;
+  harq_process->TBS = pusch_pdu->pusch_data.tb_size;
+
+  t_nrLDPC_dec_params decParams = {.check_crc = check_crc};
+  decParams.BG = pusch_pdu->maintenance_parms_v3.ldpcBaseGraph;
+  const uint32_t A = (harq_process->TBS) << 3;
+  NR_gNB_PHY_STATS_t *stats = get_phy_stats(phy_vars_gNB, ulsch->rnti);
+  if (stats) {
+    stats->frame = frame;
+    stats->ulsch_stats.round_trials[harq_process->round]++;
+    for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
+      stats->ulsch_stats.power[aarx] = dB_fixed_x10(pusch->ulsch_power[aarx]);
+      stats->ulsch_stats.noise_power[aarx] = dB_fixed_x10(pusch->ulsch_noise_power[aarx]);
+    }
+    if (!harq_process->harq_to_be_cleared) {
+      stats->ulsch_stats.current_Qm = Qm;
+      stats->ulsch_stats.current_RI = n_layers;
+      stats->ulsch_stats.total_bytes_tx += harq_process->TBS;
+    }
+  }
+
+  LOG_D(PHY,
+        "ULSCH Decoding, harq_pid %d rnti %x TBS %d G %d mcs %d Nl %d nb_rb %d, Qm %d, Coderate %f RV %d round %d new RX %d\n",
+        harq_pid,
+        ulsch->rnti,
+        A,
+        G,
+        mcs,
+        n_layers,
+        nb_rb,
+        Qm,
+        pusch_pdu->target_code_rate / 10240.0f,
+        pusch_pdu->pusch_data.rv_index,
+        harq_process->round,
+        harq_process->harq_to_be_cleared);
+
+  // [hna] Perform nr_segmenation with input and output set to NULL to calculate only (C, K, Z, F)
+  nr_segmentation(NULL,
+                  NULL,
+                  lenWithCrc(1, A), // size in case of 1 segment
+                  &harq_process->C,
+                  &harq_process->K,
+                  &harq_process->Z, // [hna] Z is Zc
+                  &harq_process->F,
+                  decParams.BG);
+
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS_PER_LAYER * n_layers; // number of segments to be allocated
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY, "nr_segmentation.c: too many segments %d, A %d\n", harq_process->C, A);
+    return(-1);
+  }
+  if (nb_rb != 273) {
+    a_segments = a_segments*nb_rb;
+    a_segments = a_segments/273 +1;
+  }
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
+    return -1;
+  }
+
+#ifdef DEBUG_ULSCH_DECODING
+  printf("ulsch decoding nr segmentation Z %d\n", harq_process->Z);
+  if (!frame % 100)
+    printf("K %d C %d Z %d \n", harq_process->K, harq_process->C, harq_process->Z);
+  printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
+#endif
+
+  decParams.Z = harq_process->Z;
+  decParams.numMaxIter = ulsch->max_ldpc_iterations;
+  decParams.outMode = 0;
+  decParams.setCombIn = !harq_process->harq_to_be_cleared;
+  if (harq_process->harq_to_be_cleared) {
+    for (int r = 0; r < harq_process->C; r++)
+      harq_process->d_to_be_cleared[r] = true;
+    harq_process->harq_to_be_cleared = false;
+  }
+
+  uint32_t offset = 0, r_offset = 0;
+  set_abort(&harq_process->abort_decode, false);
+  for (int r = 0; r < harq_process->C; r++) {
+    int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
+    union ldpcReqUnion id = {.s = {ulsch->rnti, frame, nr_tti_rx, 0, 0}};
+    notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(ldpcDecode_t), id.p, &phy_vars_gNB->respDecode, &nr_processULSegment_demo);
+    ldpcDecode_t *rdata = (ldpcDecode_t *)NotifiedFifoData(req);
+    decParams.R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index,
+                                        E,
+                                        decParams.BG,
+                                        decParams.Z,
+                                        &harq_process->llrLen,
+                                        harq_process->round);
+    rdata->gNB = phy_vars_gNB;
+    rdata->ulsch_harq = harq_process;
+    rdata->decoderParms = decParams;
+    rdata->ulsch_llr = ulsch_llr;
+    rdata->Kc = decParams.BG == 2 ? 52 : 68;
+    rdata->harq_pid = harq_pid;
+    rdata->segment_r = r;
+    rdata->nbSegments = harq_process->C;
+    rdata->E = E;
+    rdata->A = A;
+    rdata->Qm = Qm;
+    rdata->r_offset = r_offset;
+    rdata->Kr_bytes = harq_process->K >> 3;
+    rdata->rv_index = pusch_pdu->pusch_data.rv_index;
+    rdata->offset = offset;
+    rdata->ulsch = ulsch;
+    rdata->ulsch_id = ULSCH_id;
+    rdata->tbslbrm = pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes;
+    pushTpool(&phy_vars_gNB->threadPool, req);
+    LOG_D(PHY, "Added a block to decode, in pipe: %d\n", r);
+    r_offset += E;
+    offset += ((harq_process->K >> 3) - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+  }
+  return harq_process->C;
+}
+
+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;
+
+}
+
+int32_t nr_ulsch_decoding_decoder(PHY_VARS_gNB *gNB, NR_DL_FRAME_PARMS *frame_parms, int frame_rx, int slot_rx, uint32_t *G){
+
+  int nbDecode = 0;
+  for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
+    NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
+    if ((ulsch->active == true) && (ulsch->frame == frame_rx) && (ulsch->slot == slot_rx) && (ulsch->handled == 0)) {
+      uint8_t harq_pid = ulsch->harq_pid; 
+      nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[ULSCH_id].harq_process->ulsch_pdu;
+      nbDecode += nr_ulsch_decoding_demo(gNB, ULSCH_id, gNB->pusch_vars[ULSCH_id].llr, frame_parms, pusch_pdu, frame_rx, slot_rx, harq_pid, G[ULSCH_id]);
+    }
+  }
+
+  return nbDecode;
+
+}
+

openair1/PHY/CODING/nr_ulsch_decoding_interface_load.c

@@ -0,0 +1,80 @@
+/*
+ * 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_load.c
+ * \brief: load library implementing coding/decoding algorithms
+ * \author Francois TABURET
+ * \date 2020
+ * \version 0.1
+ * \company NOKIA BellLabs France
+ * \email: francois.taburet@nokia-bell-labs.com
+ * \note
+ * \warning
+ */
+#define _GNU_SOURCE 
+#include <sys/types.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include "assertions.h"
+#include "common/utils/LOG/log.h"
+#include "PHY/CODING/nrLDPC_extern.h"
+#include "common/config/config_userapi.h"
+#include "common/utils/load_module_shlib.h"
+#include "PHY/CODING/nr_ulsch_decoding_interface.h"
+
+/* arguments used when called from phy simulators exec's which do not use the config module */
+/* arg is used to initialize the config module so that the loader works as expected */
+char *arguments_phy_simulators[64]={"ldpctest",NULL};
+
+int load_nr_ulsch_decoding_interface(char *version, nr_ulsch_decoding_interface_t *itf)
+{
+  char *ptr = (char *)config_get_if();
+  char libname[64] = "ldpc";
+
+  if (ptr == NULL) { // phy simulators, config module possibly not loaded
+    uniqCfg = load_configmodule(1, arguments_phy_simulators, CONFIG_ENABLECMDLINEONLY);
+    logInit();
+  }
+  /* 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_encoder"}};
+  int ret;
+  ret = load_module_version_shlib(libname, version, shlib_fdesc, sizeofArray(shlib_fdesc), NULL);
+  if(ret < 0){
+    LOG_D(PHY, "NR ULSCH decoding module unavailable");
+    return ret;
+  }
+  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[2].fptr;
+
+  AssertFatal(itf->nr_ulsch_decoding_init() == 0, "error starting LDPC library %s %s\n", libname, version);
+
+  return 0;
+}
+
+int free_nr_ulsch_decoding_interface(nr_ulsch_decoding_interface_t *interface)
+{
+  return interface->nr_ulsch_decoding_shutdown();
+}

openair1/PHY/INIT/nr_init.c

@@ -27,6 +27,7 @@
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "PHY/INIT/nr_phy_init.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
+#include "PHY/CODING/nr_ulsch_decoding_interface.h"
 #include "PHY/NR_TRANSPORT/nr_transport_proto.h"
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
 #include "PHY/NR_ESTIMATION/nr_ul_estimation.h"
@@ -40,6 +41,7 @@
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "SCHED_NR/fapi_nr_l1.h"
 #include "PHY/NR_REFSIG/ul_ref_seq_nr.h"
+#include <string.h>
 
 
 int l1_north_init_gNB() {
@@ -103,6 +105,7 @@ void reset_active_stats(PHY_VARS_gNB *gNB, int frame)
 
 // A global var to reduce the changes size
 ldpc_interface_t ldpc_interface = {0}, ldpc_interface_offload = {0};
+nr_ulsch_decoding_interface_t nr_ulsch_decoding_interface = {0};
 
 int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 {
@@ -131,7 +134,14 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 
   nr_init_fde(); // Init array for frequency equalization of transform precoding of PUSCH
 
-  load_LDPClib(NULL, &ldpc_interface);
+  gNB->nr_ulsch_decoding_interface_flag = 0;
+  int ret_loader = load_nr_ulsch_decoding_interface(NULL, &nr_ulsch_decoding_interface);
+  if(ret_loader >= 0){
+    gNB->nr_ulsch_decoding_interface_flag = 1;
+    load_LDPClib("_optim8segmulti", &ldpc_interface);
+  }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,51 @@ 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);
-    start_meas(dlsch_encoding_stats);
+    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 +162,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 +174,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 +190,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 +630,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/PHY/defs_gNB.h

@@ -636,6 +636,9 @@ typedef struct PHY_VARS_gNB_s {
 
   int ldpc_offload_flag;
 
+  /// NR ULSCH decoding related
+  int nr_ulsch_decoding_interface_flag; // Flag enabling NR ULSCH decoding module
+
   int max_ldpc_iterations;
   /// indicate the channel estimation technique in time domain
   int chest_time;

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -24,6 +24,7 @@
 #include "PHY/NR_TRANSPORT/nr_transport_proto.h"
 #include "PHY/NR_TRANSPORT/nr_dlsch.h"
 #include "PHY/NR_TRANSPORT/nr_ulsch.h"
+#include "PHY/CODING/nr_ulsch_decoding_interface.h"
 #include "PHY/NR_TRANSPORT/nr_dci.h"
 #include "PHY/NR_ESTIMATION/nr_ul_estimation.h"
 #include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h"
@@ -381,6 +382,66 @@ static void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req)
   }
 }
 
+static int nr_ulsch_procedures_slot(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
+{
+  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
+  uint32_t *G = malloc(gNB->max_nb_pusch*sizeof(uint32_t));
+  for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
+
+    NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
+    if ((ulsch->active == true) && (ulsch->frame == frame_rx) && (ulsch->slot == slot_rx) && (ulsch->handled == 0)) {
+
+      nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[ULSCH_id].harq_process->ulsch_pdu;
+
+      uint16_t nb_re_dmrs;
+      uint16_t start_symbol = pusch_pdu->start_symbol_index;
+      uint16_t number_symbols = pusch_pdu->nr_of_symbols;
+  
+      uint8_t number_dmrs_symbols = 0;
+      for (int l = start_symbol; l < start_symbol + number_symbols; l++)
+        number_dmrs_symbols += ((pusch_pdu->ul_dmrs_symb_pos)>>l)&0x01;
+  
+      if (pusch_pdu->dmrs_config_type==pusch_dmrs_type1)
+        nb_re_dmrs = 6*pusch_pdu->num_dmrs_cdm_grps_no_data;
+      else
+        nb_re_dmrs = 4*pusch_pdu->num_dmrs_cdm_grps_no_data;
+  
+      G[ULSCH_id] = nr_get_G(pusch_pdu->rb_size,
+                            number_symbols,
+                            nb_re_dmrs,
+                            number_dmrs_symbols, // number of dmrs symbols irrespective of single or double symbol dmrs
+                            gNB->ulsch[ULSCH_id].unav_res,
+                            pusch_pdu->qam_mod_order,
+                            pusch_pdu->nrOfLayers);
+      AssertFatal(G[ULSCH_id]>0,"G is 0 : rb_size %u, number_symbols %d, nb_re_dmrs %d, number_dmrs_symbols %d, qam_mod_order %u, nrOfLayer %u\n",
+                  pusch_pdu->rb_size,
+                  number_symbols,
+                  nb_re_dmrs,
+                  number_dmrs_symbols, // number of dmrs symbols irrespective of single or double symbol dmrs
+                  pusch_pdu->qam_mod_order,
+                  pusch_pdu->nrOfLayers);
+      LOG_D(PHY,"rb_size %d, number_symbols %d, nb_re_dmrs %d, dmrs symbol positions %d, number_dmrs_symbols %d, qam_mod_order %d, nrOfLayer %d\n",
+            pusch_pdu->rb_size,
+            number_symbols,
+            nb_re_dmrs,
+            pusch_pdu->ul_dmrs_symb_pos,
+            number_dmrs_symbols, // number of dmrs symbols irrespective of single or double symbol dmrs
+            pusch_pdu->qam_mod_order,
+            pusch_pdu->nrOfLayers);
+    }
+  }
+  
+  //----------------------------------------------------------
+  //--------------------- ULSCH decoding ---------------------
+  //----------------------------------------------------------
+
+  int nbDecode =
+      nr_ulsch_decoding_interface.nr_ulsch_decoding_decoder(gNB, frame_parms, frame_rx, slot_rx, G);
+
+  free(G);
+  return nbDecode;
+}
+
 static int nr_ulsch_procedures(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, int ULSCH_id, uint8_t harq_pid)
 {
   NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
@@ -904,12 +965,28 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RX_PUSCH, 0);
       // LOG_M("rxdataF_comp.m","rxF_comp",gNB->pusch_vars[0]->rxdataF_comp[0],6900,1,1);
       // LOG_M("rxdataF_ext.m","rxF_ext",gNB->pusch_vars[0]->rxdataF_ext[0],6900,1,1);
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX, 1);
-      int const tasks_added = nr_ulsch_procedures(gNB, frame_rx, slot_rx, ULSCH_id, ulsch->harq_pid);
-      if (tasks_added > 0)
-        totalDecode += tasks_added; 
+    }
+  }
 
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX, 0);
+  if(gNB->nr_ulsch_decoding_interface_flag){
+    int const tasks_added = nr_ulsch_procedures_slot(gNB, frame_rx, slot_rx);
+    if (tasks_added > 0)
+      totalDecode += tasks_added; 
+
+  }
+  else
+  {
+    for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
+      NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
+  
+      if ((ulsch->active == true) && (ulsch->frame == frame_rx) && (ulsch->slot == slot_rx) && (ulsch->handled == 0)) {
+        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX, 1);
+        int const tasks_added = nr_ulsch_procedures(gNB, frame_rx, slot_rx, ULSCH_id, ulsch->harq_pid);
+        if (tasks_added > 0)
+          totalDecode += tasks_added; 
+
+        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX, 0);
+      }
     }
   }
     while (totalDecode > 0) {

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -35,6 +35,7 @@
 #include "PHY/defs_nr_UE.h"
 #include "PHY/phy_vars_nr_ue.h"
 #include "PHY/types.h"
+#include "PHY/CODING/nr_ulsch_decoding_interface.h"
 #include "PHY/INIT/nr_phy_init.h"
 #include "PHY/MODULATION/modulation_UE.h"
 #include "PHY/MODULATION/nr_modulation.h"
@@ -1605,6 +1606,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);
 

targets/PROJECTS/GENERIC-NR-5GC/CONF/du.sa.band78.273prb.fhi72.4x4-benetel650.conf

@@ -0,0 +1,275 @@
+Active_gNBs = ( "gNB-OAI-DU");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe01;
+    gNB_DU_ID =  0xe01;
+    gNB_name  =  "gNB-OAI-DU";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  1;
+    plmn_list = ({ mcc = 208; mnc = 99; mnc_length = 2; snssaiList = ( { sst = 1; }); });
+
+    nr_cellid = 1;
+
+    ////////// Physical parameters:
+
+    pdsch_AntennaPorts_XP = 2; 
+#    pdsch_AntennaPorts_N1 = 2;
+    pusch_AntennaPorts    = 4; 
+    do_CSIRS              = 1;
+    do_SRS                = 0 ;
+    sib1_tda			  = 15;
+#    force_UL256qam_off    = 1;
+    pdcch_ConfigSIB1 = (
+      {
+        controlResourceSetZero = 11;
+        searchSpaceZero = 0;
+      }
+    );
+
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+     # n_TimingAdvanceOffset                                         = 0;
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3450.72 MHz (center frequency)
+      absoluteFrequencySSB                                          = 623328;
+      dl_frequencyBand                                              = 78;
+      # this is 3401.58 MHz
+      dl_absoluteFrequencyPointA                                    = 620052;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                           = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        dl_subcarrierSpacing                                        = 1;
+        dl_carrierBandwidth                                         = 273;
+     #initialDownlinkBWP
+      #genericParameters
+       initialDLBWPlocationAndBandwidth                             = 1099; #38.101-1 Table 5.3.2-1
+       #
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        initialDLBWPsubcarrierSpacing                               = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                          = 11;
+        initialDLBWPsearchSpaceZero                                 = 0;
+
+  #uplinkConfigCommon
+     #frequencyInfoUL
+      ul_frequencyBand                                              = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                             = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      ul_subcarrierSpacing                                          = 1;
+      ul_carrierBandwidth                                           = 273;
+      pMax                                                          = 23;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                            = 1099;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        initialULBWPsubcarrierSpacing                               = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 151;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 0;
+          preambleReceivedTargetPower                               = -100;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 8;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 3;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 5;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 3;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 15;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #
+        msg1_SubcarrierSpacing                                      = 1,
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+
+# this is the offset between the last PRACH preamble power and the Msg3 PUSCH, 2 times the field value in dB
+        msg3_DeltaPreamble                                          = 2;
+        p0_NominalWithGrant                                         = -96;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 0;
+        p0_nominal                                                  = -96;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 0x1;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7;
+      nrofDownlinkSymbols                                           = 6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4;
+
+  ssPBCH_BlockPower                                                 = 10;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+  }
+);
+
+
+MACRLCs = (
+{
+  num_cc                      = 1;
+  tr_s_preference             = "local_L1";
+  tr_n_preference             = "f1";
+  local_n_if_name             = "enp193s0f0";
+  local_n_address             = "172.21.16.51";
+  remote_n_address            = "172.21.6.92"; #JF 172.21.6.90=CUCP, 172.21.6.92=CU
+  local_n_portc               = 500;
+  local_n_portd               = 2153; #JF 2152
+  remote_n_portc              = 501;
+  remote_n_portd              = 2153; #JF 2152
+  pusch_TargetSNRx10          = 230; #JF 80
+  pucch_TargetSNRx10          = 230;
+  dl_bler_target_upper=.35;
+  dl_bler_target_lower=.15; 
+  ul_bler_target_upper=.35;
+  ul_bler_target_lower=.15;
+  pusch_FailureThres          = 100;
+  ul_max_mcs                  = 28;
+}
+);
+
+L1s = (
+{
+  num_cc = 1;
+  tr_n_preference = "local_mac";
+  prach_dtx_threshold = 100;
+  pucch0_dtx_threshold = 80;
+  pusch_dtx_threshold = 200;
+  max_ldpc_iterations = 10;
+  tx_amp_backoff_dB = 12; # needs to match O-RU configuration
+  L1_rx_thread_core = 8;
+  L1_tx_thread_core = 10; # relevant after merge of l1_tx_thread
+  phase_compensation = 0; # needs to match O-RU configuration
+}
+);
+
+RUs = (
+{
+  local_rf       = "no";
+  nb_tx          = 4;
+  nb_rx          = 4;
+  att_tx         = 0
+  att_rx         = 0;
+  bands          = [78];
+  max_pdschReferenceSignalPower = -27;
+  max_rxgain                    = 75;
+  sf_extension                  = 0;
+  eNB_instances  = [0];
+  ru_thread_core = 9;
+  sl_ahead       = 10;
+  ##beamforming 1x2 matrix: 1 layer x 2 antennas
+  bf_weights = [0x00007fff, 0x0000,0x00007fff, 0x0000];
+  tr_preference  = "raw_if4p5"; # important: activate FHI7.2
+  do_precoding = 0; # needs to match O-RU configuration
+}
+);
+
+log_config :
+{
+  global_log_level                      ="info";
+  hw_log_level                          ="info";
+  phy_log_level                         ="info";
+  mac_log_level                         ="info";
+  rlc_log_level                         ="info";
+  pdcp_log_level                        ="info";
+  rrc_log_level                         ="info";
+  ngap_log_level                        ="info";
+  f1ap_log_level                        ="info";
+};
+
+fhi_72 = {
+  dpdk_devices = ("0000:c1:11.0", "0000:c1:11.1");
+  io_core = 1;
+  worker_cores = (2);
+  du_addr = ("00:11:22:33:44:66", "00:11:22:33:44:67");
+  ru_addr = ("70:b3:d5:e1:5b:ff", "70:b3:d5:e1:5b:ff");
+  mtu = 9216;
+  file_prefix = "fhi_72";
+  fh_config = ({
+    Tadv_cp_dl = 125;
+    T2a_cp_dl = (259, 500);
+    T2a_cp_ul = (25, 500);
+    T2a_up = (134, 375);
+    Ta3 = (152, 160);
+    T1a_cp_dl = (419, 470);
+    T1a_cp_ul = (285, 336);
+    T1a_up = (294, 345);
+    Ta4 = (0, 200);
+    ru_config = {
+      iq_width = 9;
+      iq_width_prach = 9;
+      fft_size = 12;
+    };
+    prach_config = {
+      eAxC_offset = 4;
+    };
+  });
+};