Merge remote-tracking branch 'origin/NR_MIMO_memory' into integration_2022_wk11

cmake_targets/autotests/test_case_list.xml

@@ -1093,10 +1093,10 @@
                                  (Test8: 217 PRB 100 PDSCH-PRBs 110 PDSCH-Offset),
                                  (Test9: 106 PRBs 50 PDSCH-PRBs MCS Index 27),
                                  (Test10: 106 PRBs 50 PDSCH-PRBs MCS Index 16),
-                                 (Test11: 106 MCS-TABLE 256 QAM MCS Index 26),
-                                 (Test12: HARQ test 25% TP (4 rounds),
-                                 (Test13: HARQ test 33% TP (3 rounds),
-                                 (Test14: HARQ test 50% TP (2 rounds),
+                                 (Test11: 106 MCS-TABLE 256 QAM MCS Index 27),
+                                 (Test12: HARQ test 25% TP 4 rounds),
+                                 (Test13: HARQ test 33% TP 3 rounds),
+                                 (Test14: HARQ test 50% TP 2 rounds),
                                  (Test15: 3 PTRS, 8 Interpolated Symbols),
                                  (Test16: 6 PTRS, 5 Interpolated Symbols),
                                  (Test17: 11 PTRS, 0 Interpolated Symbols),

executables/nr-gnb.c

@@ -177,15 +177,14 @@ void rx_func(void *param) {
     void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
     int j;
     for (j = 0; j < NUMBER_OF_NR_ULSCH_MAX; j++)
-      if (gNB->ulsch[j][0]->rnti == rnti_to_remove[i]) {
-        gNB->ulsch[j][0]->rnti = 0;
-        gNB->ulsch[j][0]->harq_mask = 0;
-        //clean_gNB_ulsch(gNB->ulsch[j][0]);
+      if (gNB->ulsch[j]->rnti == rnti_to_remove[i]) {
+        gNB->ulsch[j]->rnti = 0;
+        gNB->ulsch[j]->harq_mask = 0;
         int h;
         for (h = 0; h < NR_MAX_ULSCH_HARQ_PROCESSES; h++) {
-          gNB->ulsch[j][0]->harq_processes[h]->status = SCH_IDLE;
-          gNB->ulsch[j][0]->harq_processes[h]->round  = 0;
-          gNB->ulsch[j][0]->harq_processes[h]->handled = 0;
+          gNB->ulsch[j]->harq_processes[h]->status = SCH_IDLE;
+          gNB->ulsch[j]->harq_processes[h]->round  = 0;
+          gNB->ulsch[j]->harq_processes[h]->handled = 0;
         }
         up_removed++;
       }

executables/nr-ue.c

@@ -18,7 +18,8 @@
  * For more information about the OpenAirInterface (OAI) Software Alliance:
  *      contact@openairinterface.org
  */
-#define _GNU_SOURCE 
+
+#define _GNU_SOURCE
 #include <pthread.h>
 #include <openair1/PHY/impl_defs_top.h>
 #include "executables/nr-uesoftmodem.h"

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -117,7 +117,7 @@ int test_ldpc(short No_iteration,
   sigma = 1.0/sqrt(2*SNR);
   opp_enabled=1;
   //short test_input[block_length];
-  unsigned char *test_input[MAX_NUM_NR_DLSCH_SEGMENTS]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};;
+  unsigned char *test_input[MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*NR_MAX_NB_LAYERS]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};;
   //short *c; //padded codeword
   unsigned char estimated_output[MAX_NUM_DLSCH_SEGMENTS][block_length];
   memset(estimated_output, 0, sizeof(estimated_output));

openair1/PHY/CODING/nrLDPC_defs.h

@@ -57,7 +57,7 @@ typedef struct {
   /// Number of "Filler" bits
   uint32_t F;
   /// LDPC-code outputs
-  uint8_t *d[MAX_NUM_NR_DLSCH_SEGMENTS];
+  uint8_t *d[MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*NR_MAX_NB_LAYERS];
 } encoder_implemparams_t;
 #define INIT0_LDPCIMPLEMPARAMS {0,0,0,NULL,NULL,NULL,NULL}
 typedef void(*nrLDPC_initcallfunc_t)(t_nrLDPC_dec_params *p_decParams, int8_t *p_llr, int8_t *p_out);

openair1/PHY/CODING/nr_segmentation.c

@@ -63,11 +63,6 @@ int32_t nr_segmentation(unsigned char *input_buffer,
 #endif
   }
 
-  if ((*C)>MAX_NUM_NR_DLSCH_SEGMENTS) {
-    LOG_E(PHY,"nr_segmentation.c: too many segments %d, B %d, L %d, Bprime %d\n",*C,B,L,Bprime);
-    return(-1);
-  }
-
   // Find K+
   Kprime = Bprime/(*C);
 

openair1/PHY/INIT/nr_init.c

@@ -117,12 +117,15 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
 
   gNB->bad_pucch = 0;
 
+  // ceil(((NB_RB<<1)*3)/32) // 3 RE *2(QPSK)
+  int pdcch_dmrs_init_length =  (((fp->N_RB_DL<<1)*3)>>5)+1;
+
   for (int slot=0; slot<fp->slots_per_frame; slot++) {
     pdcch_dmrs[slot] = (uint32_t **)malloc16(fp->symbols_per_slot*sizeof(uint32_t *));
     AssertFatal(pdcch_dmrs[slot]!=NULL, "NR init: pdcch_dmrs for slot %d - malloc failed\n", slot);
 
     for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-      pdcch_dmrs[slot][symb] = (uint32_t *)malloc16(NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD*sizeof(uint32_t));
+      pdcch_dmrs[slot][symb] = (uint32_t *)malloc16(pdcch_dmrs_init_length*sizeof(uint32_t));
       LOG_D(PHY,"pdcch_dmrs[%d][%d] %p\n",slot,symb,pdcch_dmrs[slot][symb]);
       AssertFatal(pdcch_dmrs[slot][symb]!=NULL, "NR init: pdcch_dmrs for slot %d symbol %d - malloc failed\n", slot, symb);
     }
@@ -136,16 +139,19 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   gNB->nr_gold_pdsch_dmrs = (uint32_t ****)malloc16(fp->slots_per_frame*sizeof(uint32_t ***));
   uint32_t ****pdsch_dmrs             = gNB->nr_gold_pdsch_dmrs;
 
+  // ceil(((NB_RB*6(k)*2(QPSK)/32) // 3 RE *2(QPSK)
+  int pdsch_dmrs_init_length =  ((fp->N_RB_DL*12)>>5)+1;
   for (int slot=0; slot<fp->slots_per_frame; slot++) {
     pdsch_dmrs[slot] = (uint32_t ***)malloc16(fp->symbols_per_slot*sizeof(uint32_t **));
     AssertFatal(pdsch_dmrs[slot]!=NULL, "NR init: pdsch_dmrs for slot %d - malloc failed\n", slot);
 
+    int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
     for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-      pdsch_dmrs[slot][symb] = (uint32_t **)malloc16(NR_MAX_NB_CODEWORDS*sizeof(uint32_t *));
+      pdsch_dmrs[slot][symb] = (uint32_t **)malloc16(nb_codewords*sizeof(uint32_t *));
       AssertFatal(pdsch_dmrs[slot][symb]!=NULL, "NR init: pdsch_dmrs for slot %d symbol %d - malloc failed\n", slot, symb);
 
-      for (int q=0; q<NR_MAX_NB_CODEWORDS; q++) {
-        pdsch_dmrs[slot][symb][q] = (uint32_t *)malloc16(NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD*sizeof(uint32_t));
+      for (int q=0; q<nb_codewords; q++) {
+        pdsch_dmrs[slot][symb][q] = (uint32_t *)malloc16(pdsch_dmrs_init_length*sizeof(uint32_t));
         AssertFatal(pdsch_dmrs[slot][symb][q]!=NULL, "NR init: pdsch_dmrs for slot %d symbol %d codeword %d - malloc failed\n", slot, symb, q);
       }
     }
@@ -158,6 +164,8 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
 
   uint32_t ****pusch_dmrs = gNB->nr_gold_pusch_dmrs;
 
+  // ceil(((NB_RB*6(k)*2(QPSK)/32) // 3 RE *2(QPSK)
+  int pusch_dmrs_init_length =  ((fp->N_RB_UL*12)>>5)+1;
   for(int nscid=0; nscid<2; nscid++) {
     pusch_dmrs[nscid] = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t **));
     AssertFatal(pusch_dmrs[nscid]!=NULL, "NR init: pusch_dmrs for nscid %d - malloc failed\n", nscid);
@@ -167,7 +175,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
       AssertFatal(pusch_dmrs[nscid][slot]!=NULL, "NR init: pusch_dmrs for slot %d - malloc failed\n", slot);
 
       for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-        pusch_dmrs[nscid][slot][symb] = (uint32_t *)malloc16(NR_MAX_PUSCH_DMRS_INIT_LENGTH_DWORD*sizeof(uint32_t));
+        pusch_dmrs[nscid][slot][symb] = (uint32_t *)malloc16(pusch_dmrs_init_length*sizeof(uint32_t));
         AssertFatal(pusch_dmrs[nscid][slot][symb]!=NULL, "NR init: pusch_dmrs for slot %d symbol %d - malloc failed\n", slot, symb);
       }
     }
@@ -182,12 +190,15 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   uint32_t ***csi_rs = gNB->nr_gold_csi_rs;
   AssertFatal(csi_rs!=NULL, "NR init: csi reference signal malloc failed\n");
 
+  // ceil((NB_RB*8(max allocation per RB)*2(QPSK))/32)
+  int csi_dmrs_init_length =  ((fp->N_RB_DL<<4)>>5)+1;
+
   for (int slot=0; slot<fp->slots_per_frame; slot++) {
     csi_rs[slot] = (uint32_t **)malloc16(fp->symbols_per_slot*sizeof(uint32_t *));
     AssertFatal(csi_rs[slot]!=NULL, "NR init: csi reference signal for slot %d - malloc failed\n", slot);
 
     for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-      csi_rs[slot][symb] = (uint32_t *)malloc16(NR_MAX_CSI_RS_INIT_LENGTH_DWORD*sizeof(uint32_t));
+      csi_rs[slot][symb] = (uint32_t *)malloc16(csi_dmrs_init_length*sizeof(uint32_t));
       AssertFatal(csi_rs[slot][symb]!=NULL, "NR init: csi reference signal for slot %d symbol %d - malloc failed\n", slot, symb);
     }
   }
@@ -196,6 +207,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
 
   for (int id=0; id<NUMBER_OF_NR_SRS_MAX; id++) {
     gNB->nr_srs_info[id] = (nr_srs_info_t *)malloc16_clear(sizeof(nr_srs_info_t));
+    gNB->nr_srs_info[id]->sc_list = (uint16_t *) malloc16_clear(6*fp->N_RB_UL*sizeof(uint16_t));
     gNB->nr_srs_info[id]->srs_generated_signal = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
     gNB->nr_srs_info[id]->noise_power = (uint32_t*)malloc16_clear(sizeof(uint32_t));
     gNB->nr_srs_info[id]->srs_received_signal = (int32_t **)malloc16(Prx*sizeof(int32_t*));
@@ -314,9 +326,10 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   free_and_zero(pdcch_dmrs);
 
   uint32_t ****pdsch_dmrs = gNB->nr_gold_pdsch_dmrs;
+  int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
   for (int slot = 0; slot < fp->slots_per_frame; slot++) {
     for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
-      for (int q = 0; q < NR_MAX_NB_CODEWORDS; q++)
+      for (int q = 0; q < nb_codewords; q++)
         free_and_zero(pdsch_dmrs[slot][symb][q]);
       free_and_zero(pdsch_dmrs[slot][symb]);
     }
@@ -351,6 +364,7 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
       free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time[i]);
       free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i]);
     }
+    free_and_zero(gNB->nr_srs_info[id]->sc_list);
     free_and_zero(gNB->nr_srs_info[id]->srs_generated_signal);
     free_and_zero(gNB->nr_srs_info[id]->noise_power);
     free_and_zero(gNB->nr_srs_info[id]->srs_received_signal);
@@ -559,9 +573,10 @@ void init_DLSCH_struct(PHY_VARS_gNB *gNB, processingData_L1tx_t *msg) {
   uint16_t grid_size = cfg->carrier_config.dl_grid_size[fp->numerology_index].value;
   msg->num_pdsch_slot = 0;
 
+  int num_cw = NR_MAX_NB_LAYERS > 4? 2:1;
   for (int i=0; i<gNB->number_of_nr_dlsch_max; i++) {
     LOG_I(PHY,"Allocating Transport Channel Buffers for DLSCH %d/%d\n",i,gNB->number_of_nr_dlsch_max);
-    for (int j=0; j<2; j++) {
+    for (int j=0; j<num_cw; j++) {
       msg->dlsch[i][j] = new_gNB_dlsch(fp,1,16,NSOFT,0,grid_size);
       AssertFatal(msg->dlsch[i][j]!=NULL,"Can't initialize dlsch %d \n", i);
     }
@@ -573,9 +588,10 @@ void reset_DLSCH_struct(const PHY_VARS_gNB *gNB, processingData_L1tx_t *msg)
   const NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   const nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
   const uint16_t grid_size = cfg->carrier_config.dl_grid_size[fp->numerology_index].value;
+  int num_cw = NR_MAX_NB_LAYERS > 4? 2:1;
   for (int i=0; i<gNB->number_of_nr_dlsch_max; i++)
-    for (int j=0; j<2; j++)
-      free_gNB_dlsch(&msg->dlsch[i][j], grid_size);
+    for (int j=0; j<num_cw; j++)
+      free_gNB_dlsch(&msg->dlsch[i][j], grid_size, fp);
 }
 
 void init_nr_transport(PHY_VARS_gNB *gNB) {
@@ -600,22 +616,16 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {
 
     LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH  %d/%d\n",i,gNB->number_of_nr_ulsch_max);
 
-    for (int j=0; j<2; j++) {
-      // ULSCH for data
-      gNB->ulsch[i][j] = new_gNB_ulsch(MAX_LDPC_ITERATIONS, fp->N_RB_UL);
-
-      if (!gNB->ulsch[i][j]) {
-        LOG_E(PHY,"Can't get gNB ulsch structures\n");
-        exit(-1);
-      }
+    gNB->ulsch[i] = new_gNB_ulsch(MAX_LDPC_ITERATIONS, fp->N_RB_UL);
 
+    if (!gNB->ulsch[i]) {
+      LOG_E(PHY,"Can't get gNB ulsch structures\n");
+      exit(-1);
     }
-
   }
 
   gNB->rx_total_gain_dB=130;
 
-
   //fp->pucch_config_common.deltaPUCCH_Shift = 1;
 }
 
@@ -630,6 +640,5 @@ void reset_nr_transport(PHY_VARS_gNB *gNB)
     free_gNB_srs(gNB->srs[i]);
 
   for (int i=0; i<gNB->number_of_nr_ulsch_max; i++)
-    for (int j=0; j<2; j++)
-      free_gNB_ulsch(&gNB->ulsch[i][j], fp->N_RB_UL);
+    free_gNB_ulsch(&gNB->ulsch[i], fp->N_RB_UL);
 }

openair1/PHY/INIT/nr_parms.c

@@ -253,7 +253,6 @@ int nr_init_frame_parms(nfapi_nr_config_request_scf_t* cfg,
 
   LOG_I(PHY,"Initializing frame parms for mu %d, N_RB %d, Ncp %d\n",mu, fp->N_RB_DL, Ncp);
 
-
   if (Ncp == NFAPI_CP_EXTENDED)
     AssertFatal(mu == NR_MU_2,"Invalid cyclic prefix %d for numerology index %d\n", Ncp, mu);
 

openair1/PHY/MODULATION/nr_modulation.c

@@ -320,98 +320,16 @@ void nr_layer_mapping(int16_t **mod_symbs,
   }
 }
 
-void nr_ue_layer_mapping(NR_UE_ULSCH_t **ulsch_ue,
+void nr_ue_layer_mapping(int16_t *mod_symbs,
                          uint8_t n_layers,
                          uint16_t n_symbs,
-                         int16_t **tx_layers)
-{
-  int16_t *mod_symbs;
-
-  switch (n_layers) {
-
-    case 1:
-      mod_symbs = (int16_t *)ulsch_ue[0]->d_mod;
-      for (int i=0; i<n_symbs; i++) {
-        tx_layers[0][i<<1] = (mod_symbs[i<<1]*AMP)>>15;
-        tx_layers[0][(i<<1)+1] = (mod_symbs[(i<<1)+1]*AMP)>>15;
-      }
-      break;
-
-    case 2:
-    case 3:
-    case 4:
-      mod_symbs = (int16_t *)ulsch_ue[0]->d_mod;
-
-      for (int i=0; i<n_symbs/n_layers; i++) {
-        for (int l=0; l<n_layers; l++) {
-          tx_layers[l][i<<1] = (mod_symbs[(n_layers*i+l)<<1]*AMP)>>15;
-          tx_layers[l][(i<<1)+1] = (mod_symbs[((n_layers*i+l)<<1)+1]*AMP)>>15;
-        }
-      }
-      break;
-
-    case 5:
-      mod_symbs = (int16_t *)ulsch_ue[0]->d_mod;
-
-      for (int i=0; i<n_symbs>>1; i++)
-        for (int l=0; l<2; l++) {
-          tx_layers[l][i<<1] = (mod_symbs[((i<<1)+l)<<1]*AMP)>>15;
-          tx_layers[l][(i<<1)+1] = (mod_symbs[(((i<<1)+l)<<1)+1]*AMP)>>15;
-        }
-
-      mod_symbs = (int16_t *)ulsch_ue[1]->d_mod;
-
-      for (int i=0; i<n_symbs/3; i++)
-        for (int l=2; l<5; l++) {
-          tx_layers[l][i<<1] = (mod_symbs[(3*i+l)<<1]*AMP)>>15;
-          tx_layers[l][(i<<1)+1] = (mod_symbs[((3*i+l)<<1)+1]*AMP)>>15;
-      }
-      break;
-
-    case 6:
-      for (int q=0; q<2; q++) {
-        mod_symbs = (int16_t *)ulsch_ue[q]->d_mod;
+                         int16_t **tx_layers) {
 
-        for (int i=0; i<n_symbs/3; i++)
-          for (int l=0; l<3; l++) {
-            tx_layers[l][i<<1] = (mod_symbs[(3*i+l)<<1]*AMP)>>15;
-            tx_layers[l][(i<<1)+1] = (mod_symbs[((3*i+l)<<1)+1]*AMP)>>15;
-          }
-      }
-      break;
-
-    case 7:
-      mod_symbs = (int16_t *)ulsch_ue[1]->d_mod;
-
-      for (int i=0; i<n_symbs/3; i++)
-        for (int l=0; l<3; l++) {
-          tx_layers[l][i<<1] = (mod_symbs[(3*i+l)<<1]*AMP)>>15;
-          tx_layers[l][(i<<1)+1] = (mod_symbs[((3*i+l)<<1)+1]*AMP)>>15;
-        }
-
-      mod_symbs = (int16_t *)ulsch_ue[0]->d_mod;
-
-      for (int i=0; i<n_symbs/4; i++)
-        for (int l=3; l<7; l++) {
-          tx_layers[l][i<<1] = (mod_symbs[((i<<2)+l)<<1]*AMP)>>15;
-          tx_layers[l][(i<<1)+1] = (mod_symbs[(((i<<2)+l)<<1)+1]*AMP)>>15;
-        }
-      break;
-
-    case 8:
-      for (int q=0; q<2; q++) {
-        mod_symbs = (int16_t *)ulsch_ue[q]->d_mod;
-
-        for (int i=0; i<n_symbs>>2; i++)
-          for (int l=0; l<3; l++) {
-            tx_layers[l][i<<1] = (mod_symbs[((i<<2)+l)<<1]*AMP)>>15;
-            tx_layers[l][(i<<1)+1] = (mod_symbs[(((i<<2)+l)<<1)+1]*AMP)>>15;
-          }
-      }
-      break;
-
-    default:
-      AssertFatal(0, "Invalid number of layers %d\n", n_layers);
+  for (int i=0; i<n_symbs/n_layers; i++) {
+    for (int l=0; l<n_layers; l++) {
+      tx_layers[l][i<<1] = (mod_symbs[(n_layers*i+l)<<1]*AMP)>>15;
+      tx_layers[l][(i<<1)+1] = (mod_symbs[((n_layers*i+l)<<1)+1]*AMP)>>15;
+    }
   }
 }
 

openair1/PHY/MODULATION/nr_modulation.h

@@ -66,7 +66,7 @@ void nr_layer_mapping(int16_t **mod_symbs,
   @param[out] tx_layers, modulated symbols for each layer
 */
 
-void nr_ue_layer_mapping(NR_UE_ULSCH_t **ulsch_ue,
+void nr_ue_layer_mapping(int16_t *mod_symbs,
                          uint8_t n_layers,
                          uint16_t n_symbs,
                          int16_t **tx_layers);

openair1/PHY/NR_ESTIMATION/nr_measurements_gNB.c

@@ -184,7 +184,7 @@ void nr_gnb_measurements(PHY_VARS_gNB *gNB, uint8_t ulsch_id, unsigned char harq
   PHY_MEASUREMENTS_gNB *meas = &gNB->measurements;
   NR_DL_FRAME_PARMS      *fp = &gNB->frame_parms;
   int              ch_offset = fp->ofdm_symbol_size * symbol;
-  int                N_RB_UL = gNB->ulsch[ulsch_id][0]->harq_processes[harq_pid]->ulsch_pdu.rb_size;
+  int                N_RB_UL = gNB->ulsch[ulsch_id]->harq_processes[harq_pid]->ulsch_pdu.rb_size;
 
   rx_power_tot[ulsch_id] = 0;
 

openair1/PHY/NR_REFSIG/nr_gold.c

@@ -60,6 +60,7 @@ void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
   uint8_t reset;
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   uint32_t ***pdcch_dmrs = gNB->nr_gold_pdcch_dmrs;
+  int pdcch_dmrs_init_length =  (((fp->N_RB_DL<<1)*3)>>5)+1;
 
   for (uint8_t slot=0; slot<fp->slots_per_frame; slot++) {
     for (uint8_t symb=0; symb<fp->symbols_per_slot; symb++) {
@@ -67,7 +68,7 @@ void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
       reset = 1;
       x2 = ((1<<17) * (fp->symbols_per_slot*slot+symb+1) * ((Nid<<1)+1) + (Nid<<1));
       LOG_D(PHY,"PDCCH DMRS slot %d, symb %d, Nid %d, x2 %x\n",slot,symb,Nid,x2);
-      for (uint32_t n=0; n<NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD; n++) {
+      for (uint32_t n=0; n<pdcch_dmrs_init_length; n++) {
         pdcch_dmrs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
         reset = 0;
       }
@@ -81,11 +82,12 @@ void nr_init_pdsch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
 {
   
   uint32_t x1, x2;
-  uint8_t reset, q;
+  uint8_t reset;
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   uint32_t ****pdsch_dmrs = gNB->nr_gold_pdsch_dmrs;
-
-  uint16_t N_n_scid[NR_MAX_NB_CODEWORDS]={Nid, Nid}; // Not correct, appropriate scrambling IDs have to be updated to support DCI 1_1
+  int pdsch_dmrs_init_length =  ((fp->N_RB_DL*12)>>5)+1;
+  int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
+  uint16_t N_n_scid[2]={Nid, Nid};
   uint8_t n_scid=0; // again works only for 1_0
   for (uint8_t slot=0; slot<fp->slots_per_frame; slot++) {
 
@@ -93,13 +95,13 @@ void nr_init_pdsch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
         reset = 1;
         x2 = ((1<<17) * (fp->symbols_per_slot*slot+symb+1) * ((N_n_scid[n_scid]<<1)+1) +((N_n_scid[n_scid]<<1)+n_scid));
 	      LOG_D(PHY,"PDSCH DMRS slot %d, symb %d x2 %x, N_n_scid %d,n_scid %d\n",slot,symb,x2,N_n_scid[n_scid],n_scid);
-        for (uint32_t n=0; n<NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD; n++) {
+        for (uint32_t n=0; n<pdsch_dmrs_init_length; n++) {
           pdsch_dmrs[slot][symb][0][n] = lte_gold_generic(&x1, &x2, reset);
           reset = 0;
         }
 
-        for (q = 1; q < NR_MAX_NB_CODEWORDS; q++)
-          memcpy(pdsch_dmrs[slot][symb][q],pdsch_dmrs[slot][symb][0],sizeof(uint32_t)*NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD);
+        if(nb_codewords>1)
+          memcpy(pdsch_dmrs[slot][symb][1],pdsch_dmrs[slot][symb][0],sizeof(uint32_t)*pdsch_dmrs_init_length);
     }
   }
 }
@@ -113,6 +115,7 @@ void nr_gold_pusch(PHY_VARS_gNB* gNB, uint32_t *Nid) {
   unsigned int nid;
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   unsigned short l;
+  int pusch_dmrs_init_length =  ((fp->N_RB_UL*12)>>5)+1;
 
   for (nscid=0; nscid<2; nscid++) {
     nid = Nid[nscid];
@@ -122,7 +125,7 @@ void nr_gold_pusch(PHY_VARS_gNB* gNB, uint32_t *Nid) {
         x2 = ((1<<17) * (fp->symbols_per_slot*ns+l+1) * ((nid<<1)+1) +((nid<<1)+nscid));
         LOG_D(PHY,"DMRS slot %d, symb %d x2 %x\n",ns,l,x2);
 
-        for (n=0; n<NR_MAX_PUSCH_DMRS_INIT_LENGTH_DWORD; n++) {
+        for (n=0; n<pusch_dmrs_init_length; n++) {
           gNB->nr_gold_pusch_dmrs[nscid][ns][l][n] = lte_gold_generic(&x1, &x2, reset);
           reset = 0;
         }
@@ -138,6 +141,7 @@ void nr_init_csi_rs(PHY_VARS_gNB* gNB, uint32_t Nid)
   uint32_t ***csi_rs = gNB->nr_gold_csi_rs;
   uint32_t x1, x2;
   uint8_t reset;
+  int csi_dmrs_init_length =  ((fp->N_RB_DL<<4)>>5)+1;
 
   for (uint8_t slot=0; slot<fp->slots_per_frame; slot++) {
     for (uint8_t symb=0; symb<fp->symbols_per_slot; symb++) {
@@ -145,7 +149,7 @@ void nr_init_csi_rs(PHY_VARS_gNB* gNB, uint32_t Nid)
       reset = 1;
       x2 = ((1<<10) * (fp->symbols_per_slot*slot+symb+1) * ((Nid<<1)+1) + (Nid));
 
-      for (uint32_t n=0; n<NR_MAX_CSI_RS_INIT_LENGTH_DWORD; n++) {
+      for (uint32_t n=0; n<csi_dmrs_init_length; n++) {
         csi_rs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
         reset = 0;
       }

openair1/PHY/NR_REFSIG/nr_gold_ue.c

@@ -57,6 +57,7 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
   unsigned char ns,l;
   unsigned int n,x1,x2,x2tmp0;
   uint8_t reset;
+  int pdcch_dmrs_init_length =  (((ue->frame_parms.N_RB_DL<<1)*3)>>5)+1;
 
   for (ns=0; ns<ue->frame_parms.slots_per_frame; ns++) {
 
@@ -66,7 +67,7 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
       x2tmp0 = ((ue->frame_parms.symbols_per_slot*ns+l+1)*((nid<<1)+1))<<17;
       x2 = (x2tmp0+(nid<<1))%(1U<<31);  //cinit
       
-      for (n=0; n<NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD; n++) {
+      for (n=0; n<pdcch_dmrs_init_length; n++) {
         ue->nr_gold_pdcch[0][ns][l][n] = lte_gold_generic(&x1, &x2, reset);
         reset = 0;
       }    
@@ -77,28 +78,28 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
 void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
                    unsigned short *n_idDMRS)
 {
-  unsigned char l;
-  unsigned int n,x1,x2,x2tmp0,ns;
-  int nscid;
+
+  unsigned int x1,x2,x2tmp0;
   unsigned int nid;
   uint8_t reset;
-
+  int pdsch_dmrs_init_length =  ((ue->frame_parms.N_RB_DL*12)>>5)+1;
+  int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
   /// to be updated from higher layer
   //unsigned short lbar = 0;
 
-  for (nscid=0; nscid<2; nscid++) {
-    for (ns=0; ns<ue->frame_parms.slots_per_frame; ns++) {
+  for (int nscid=0; nscid<nb_codewords; nscid++) {
+    for (int ns=0; ns<ue->frame_parms.slots_per_frame; ns++) {
 
       nid = n_idDMRS[nscid];
 
-      for (l=0; l<ue->frame_parms.symbols_per_slot; l++) {
+      for (int l=0; l<ue->frame_parms.symbols_per_slot; l++) {
 
         reset = 1;
         x2tmp0 = ((ue->frame_parms.symbols_per_slot*ns+l+1)*((nid<<1)+1))<<17;
         x2 = (x2tmp0+(nid<<1)+nscid)%(1U<<31);  //cinit
         LOG_D(PHY,"UE DMRS slot %d, symb %d, x2 %x, nscid %d\n",ns,l,x2,nscid);
 
-        for (n=0; n<NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD; n++) {
+        for (int n=0; n<pdsch_dmrs_init_length; n++) {
           ue->nr_gold_pdsch[0][ns][l][nscid][n] = lte_gold_generic(&x1, &x2, reset);
           reset = 0;
         }
@@ -112,9 +113,10 @@ void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue,
                         uint8_t n_scid)
 {
   uint32_t x1, x2, n;
-  uint8_t reset, slot, symb, q;
+  uint8_t reset, slot, symb;
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
-  uint32_t ****pusch_dmrs = ue->nr_gold_pusch_dmrs;
+  uint32_t ***pusch_dmrs = ue->nr_gold_pusch_dmrs;
+  int pusch_dmrs_init_length =  ((fp->N_RB_UL*12)>>5)+1;
 
   for (slot=0; slot<fp->slots_per_frame; slot++) {
 
@@ -123,13 +125,10 @@ void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue,
       reset = 1;
       x2 = ((1<<17) * (fp->symbols_per_slot*slot+symb+1) * ((N_n_scid[n_scid]<<1)+1) +((N_n_scid[n_scid]<<1)+n_scid));
 
-      for (n=0; n<NR_MAX_PUSCH_DMRS_INIT_LENGTH_DWORD; n++) {
-        pusch_dmrs[slot][symb][0][n] = lte_gold_generic(&x1, &x2, reset);
+      for (n=0; n<pusch_dmrs_init_length; n++) {
+        pusch_dmrs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
         reset = 0;
       }
-
-      for (q = 1; q < NR_MAX_NB_CODEWORDS; q++)
-        memcpy(pusch_dmrs[slot][symb][q],pusch_dmrs[slot][symb][0],sizeof(uint32_t)*NR_MAX_PUSCH_DMRS_INIT_LENGTH_DWORD);
     }
   }
 }

openair1/PHY/NR_TRANSPORT/nr_csi_rs.c

@@ -37,7 +37,9 @@ void nr_generate_csi_rs(PHY_VARS_gNB *gNB,
   int32_t **txdataF = gNB->common_vars.txdataF;
   int txdataF_offset = slot*frame_parms.samples_per_slot_wCP;
   uint32_t **gold_csi_rs = gNB->nr_gold_csi_rs[slot];
-  int16_t mod_csi[frame_parms.symbols_per_slot][NR_MAX_CSI_RS_LENGTH>>1] __attribute__((aligned(16)));;
+  //*8(max allocation per RB)*2(QPSK))
+  int csi_rs_length =  frame_parms.N_RB_DL<<4;
+  int16_t mod_csi[frame_parms.symbols_per_slot][csi_rs_length>>1] __attribute__((aligned(16)));;
   uint16_t b = csi_params.freq_domain;
   uint16_t n, csi_bw, csi_start, p, k, l, mprime, na, kpn, csi_length;
   uint8_t size, ports, kprime, lprime, i, gs;
@@ -59,7 +61,7 @@ void nr_generate_csi_rs(PHY_VARS_gNB *gNB,
     for (uint8_t symb=0; symb<frame_parms.symbols_per_slot; symb++) {
       reset = 1;
       x2 = ((1<<10) * (frame_parms.symbols_per_slot*slot+symb+1) * ((Nid<<1)+1) + (Nid));
-      for (uint32_t n=0; n<NR_MAX_CSI_RS_INIT_LENGTH_DWORD; n++) {
+      for (uint32_t n=0; n<(csi_rs_length>>5)+1; n++) {
         gold_csi_rs[symb][n] = lte_gold_generic(&x1, &x2, reset);
         reset = 0;
       }

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -79,10 +79,8 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
 
     NR_DL_gNB_HARQ_t *harq = &dlsch->harq_process;
     nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &harq->pdsch_pdu.pdsch_pdu_rel15;
-    uint32_t scrambled_output[NR_MAX_NB_CODEWORDS][NR_MAX_PDSCH_ENCODED_LENGTH>>5];
     int16_t **mod_symbs = (int16_t**)dlsch->mod_symbs;
     int16_t **tx_layers = (int16_t**)dlsch->txdataF;
-    int16_t **txdataF_precoding = (int16_t**)dlsch->txdataF_precoding;
     int8_t Wf[2], Wt[2], l0, l_prime, l_overline, delta;
     uint8_t dmrs_Type = rel15->dmrsConfigType;
     int nb_re_dmrs;
@@ -100,6 +98,7 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
     uint16_t nb_re = ((12*rel15->NrOfSymbols)-nb_re_dmrs*dmrs_len-xOverhead)*rel15->rbSize*rel15->nrOfLayers;
     uint8_t Qm = rel15->qamModOrder[0];
     uint32_t encoded_length = nb_re*Qm;
+    uint32_t scrambled_output[rel15->NrOfCodewords][(encoded_length>>5)+1];
     int16_t mod_dmrs[n_dmrs<<1] __attribute__ ((aligned(16)));
 
     /* PTRS */
@@ -121,8 +120,8 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
 
     /// 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 * 8 * NR_MAX_NB_LAYERS] __attribute__((aligned(32)));
-    bzero(output,rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * 8 * NR_MAX_NB_LAYERS);
+    unsigned char output[rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers] __attribute__((aligned(32)));
+    bzero(output,rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers);
     start_meas(dlsch_encoding_stats);
 
     if (nr_dlsch_encoding(gNB,
@@ -147,20 +146,18 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
     }
     printf("\n");
 #endif
-    
-    
-    
+
     /// scrambling
     start_meas(dlsch_scrambling_stats);
-    for (int q=0; q<rel15->NrOfCodewords; q++)
-      memset((void*)scrambled_output[q], 0, (encoded_length>>5)*sizeof(uint32_t));
-    for (int q=0; q<rel15->NrOfCodewords; q++)
+    for (int q=0; q<rel15->NrOfCodewords; q++) {
+      memset((void*)scrambled_output[q], 0, ((encoded_length>>5)+1)*sizeof(uint32_t));
       nr_pdsch_codeword_scrambling(output,
                                    encoded_length,
                                    q,
                                    rel15->dataScramblingId,
                                    rel15->rnti,
                                    scrambled_output[q]);
+    }
     
     stop_meas(dlsch_scrambling_stats);
 #ifdef DEBUG_DLSCH
@@ -219,6 +216,9 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
       start_sc -= frame_parms->ofdm_symbol_size;
 
     int txdataF_offset = slot*frame_parms->samples_per_slot_wCP;
+    int16_t **txdataF_precoding = (int16_t **)malloc16(rel15->nrOfLayers*sizeof(int16_t *));
+    for (int layer = 0; layer<rel15->nrOfLayers; layer++)
+      txdataF_precoding[layer] = (int16_t *)malloc16(2*14*frame_parms->ofdm_symbol_size*sizeof(int16_t));
 
 #ifdef DEBUG_DLSCH_MAPPING
     printf("PDSCH resource mapping started (start SC %d\tstart symbol %d\tN_PRB %d\tnb_re %d,nb_layers %d)\n",
@@ -295,7 +295,7 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
           ptrs_symbol = is_ptrs_symbol(l,dlPtrsSymPos);
           if(ptrs_symbol) {
             /* PTRS QPSK Modulation for each OFDM symbol in a slot */
-            printf("Doing ptrs modulation for symbol %d, n_ptrs %d\n",l,n_ptrs);
+            LOG_D(PHY,"Doing ptrs modulation for symbol %d, n_ptrs %d\n",l,n_ptrs);
             nr_modulation(pdsch_dmrs[l][0], (n_ptrs<<1), DMRS_MOD_ORDER, mod_ptrs);
           }
         }
@@ -535,6 +535,9 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
     else {
       LOG_D(PHY,"beam index for PDSCH allocation already taken\n");
     }
+    for (int layer = 0; layer<rel15->nrOfLayers; layer++)
+      free16(txdataF_precoding[layer],2*14*frame_parms->ofdm_symbol_size);
+    free16(txdataF_precoding,rel15->nrOfLayers);
   }// dlsch loop
 }
 

openair1/PHY/NR_TRANSPORT/nr_dlsch.h

@@ -68,7 +68,6 @@ void nr_fill_dlsch(processingData_L1tx_t *msgTx,
 void nr_generate_pdsch(processingData_L1tx_t *msgTx,
                        int frame,
                        int slot);
-void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB);
 
 void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -50,10 +50,14 @@
 //#define DEBUG_DLSCH_FREE 1
 
 
-void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB) {
-  int r;
+void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, 
+                    uint16_t N_RB,
+                    const NR_DL_FRAME_PARMS* frame_parms) {
+
   NR_gNB_DLSCH_t *dlsch = *dlschptr;
-  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+
+  int max_layers = (frame_parms->nb_antennas_tx<NR_MAX_NB_LAYERS) ? frame_parms->nb_antennas_tx : NR_MAX_NB_LAYERS;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*max_layers;
 
   if (N_RB != 273) {
     a_segments = a_segments*N_RB;
@@ -65,26 +69,30 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB) {
     free16(harq->b, a_segments * 1056);
     harq->b = NULL;
   }
-  for (r = 0; r < a_segments; r++) {
+  for (int r = 0; r < a_segments; r++) {
     free(harq->c[r]);
     harq->c[r] = NULL;
   }
+  free(harq->c);
   free(harq->pdu);
 
   for (int aa = 0; aa < 64; aa++)
     free(dlsch->calib_dl_ch_estimates[aa]);
   free(dlsch->calib_dl_ch_estimates);
 
-  for (int q=0; q<NR_MAX_NB_CODEWORDS; q++)
+  int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
+  for (int q=0; q<nb_codewords; q++)
     free(dlsch->mod_symbs[q]);
+  free(dlsch->mod_symbs);
 
-  for (int layer = 0; layer < NR_MAX_NB_LAYERS; layer++) {
-    free(dlsch->txdataF_precoding[layer]);
+  for (int layer = 0; layer < max_layers; layer++) {
     free(dlsch->txdataF[layer]);
     for (int aa = 0; aa < 64; aa++)
       free(dlsch->ue_spec_bf_weights[layer][aa]);
     free(dlsch->ue_spec_bf_weights[layer]);
   }
+  free(dlsch->txdataF);
+  free(dlsch->ue_spec_bf_weights);
 
   free(dlsch);
   *dlschptr = NULL;
@@ -96,9 +104,9 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
                               uint32_t Nsoft,
                               uint8_t  abstraction_flag,
                               uint16_t N_RB) {
-  unsigned char i,r,aa,layer;
-  int re;
-  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+
+  int max_layers = (frame_parms->nb_antennas_tx<NR_MAX_NB_LAYERS) ? frame_parms->nb_antennas_tx : NR_MAX_NB_LAYERS;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*max_layers;  //number of segments to be allocated
 
   if (N_RB != 273) {
     a_segments = a_segments*N_RB;
@@ -114,31 +122,36 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
   dlsch->Mlimit = 4;
   dlsch->Nsoft = Nsoft;
 
-  for (layer=0; layer<NR_MAX_NB_LAYERS; layer++) {
+  int txdataf_size = frame_parms->N_RB_DL*NR_SYMBOLS_PER_SLOT*NR_NB_SC_PER_RB*8; // max pdsch encoded length for each layer
+
+  dlsch->txdataF = (int32_t **)malloc16(max_layers*sizeof(int32_t *));
+
+  dlsch->ue_spec_bf_weights = (int32_t ***)malloc16(max_layers*sizeof(int32_t **));
+  for (int layer=0; layer<max_layers; layer++) {
     dlsch->ue_spec_bf_weights[layer] = (int32_t **)malloc16(64*sizeof(int32_t *));
 
-    for (aa=0; aa<64; aa++) {
+    for (int aa=0; aa<64; aa++) {
       dlsch->ue_spec_bf_weights[layer][aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
 
-      for (re=0; re<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; re++) {
+      for (int re=0; re<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; re++) {
         dlsch->ue_spec_bf_weights[layer][aa][re] = 0x00007fff;
       }
     }
-
-    dlsch->txdataF[layer] = (int32_t *)malloc16((NR_MAX_PDSCH_ENCODED_LENGTH/NR_MAX_NB_LAYERS)*sizeof(int32_t)); // NR_MAX_NB_LAYERS is already included in NR_MAX_PDSCH_ENCODED_LENGTH
-    dlsch->txdataF_precoding[layer] = (int32_t *)malloc16(2*14*frame_parms->ofdm_symbol_size*sizeof(int32_t));
+    dlsch->txdataF[layer] = (int32_t *)malloc16((txdataf_size)*sizeof(int32_t));
   }
 
-  for (int q=0; q<NR_MAX_NB_CODEWORDS; q++)
-    dlsch->mod_symbs[q] = (int32_t *)malloc16(NR_MAX_PDSCH_ENCODED_LENGTH*sizeof(int32_t));
+  int nb_codewords = NR_MAX_NB_LAYERS > 4 ? 2 : 1;
+  dlsch->mod_symbs = (int32_t **)malloc16(nb_codewords*sizeof(int32_t *));
+  for (int q=0; q<nb_codewords; q++)
+    dlsch->mod_symbs[q] = (int32_t *)malloc16(txdataf_size*max_layers*sizeof(int32_t));
 
   dlsch->calib_dl_ch_estimates = (int32_t **)malloc16(64*sizeof(int32_t *));
 
-  for (aa=0; aa<64; aa++) {
+  for (int aa=0; aa<64; aa++) {
     dlsch->calib_dl_ch_estimates[aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
   }
 
-  for (i=0; i<20; i++) {
+  for (int i=0; i<20; i++) {
     dlsch->harq_ids[0][i] = 0;
     dlsch->harq_ids[1][i] = 0;
   }
@@ -153,7 +166,8 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
   nr_emulate_dlsch_payload(harq->pdu, (dlsch_bytes) >> 3);
   bzero(harq->b, dlsch_bytes);
 
-  for (r = 0; r < a_segments; r++) {
+  harq->c = (uint8_t **)malloc16(a_segments*sizeof(uint8_t *));
+  for (int r = 0; r < a_segments; r++) {
     // account for filler in first segment and CRCs for multiple segment case
     // [hna] 8448 is the maximum CB size in NR
     //       68*348 = 68*(maximum size of Zc)
@@ -316,6 +330,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     stats->current_Qm   = rel15->qamModOrder[0];
   }
 
+  int max_bytes = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*rel15->nrOfLayers*1056;
   if (A > 3824) {
     // Add 24-bit crc (polynomial A) to payload
     crc = crc24a(a,A)>>8;
@@ -326,11 +341,11 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     //printf("a0 %d a1 %d a2 %d\n", a[A>>3], a[1+(A>>3)], a[2+(A>>3)]);
     harq->B = A+24;
     //    harq->b = a;
-    AssertFatal((A / 8) + 4 <= MAX_NR_DLSCH_PAYLOAD_BYTES,
+    AssertFatal((A / 8) + 4 <= max_bytes,
                 "A %d is too big (A/8+4 = %d > %d)\n",
                 A,
                 (A / 8) + 4,
-                MAX_NR_DLSCH_PAYLOAD_BYTES);
+                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
@@ -341,11 +356,11 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     //printf("a0 %d a1 %d \n", a[A>>3], a[1+(A>>3)]);
     harq->B = A+16;
     //    harq->b = a;
-    AssertFatal((A / 8) + 3 <= MAX_NR_DLSCH_PAYLOAD_BYTES,
+    AssertFatal((A / 8) + 3 <= max_bytes,
                 "A %d is too big (A/8+3 = %d > %d)\n",
                 A,
                 (A / 8) + 3,
-                MAX_NR_DLSCH_PAYLOAD_BYTES);
+                max_bytes);
     memcpy(harq->b, a, (A / 8) + 3); // using 3 bytes to mimic the case of 24 bit crc
   }
 
@@ -363,6 +378,11 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   impp.Kb = nr_segmentation(harq->b, harq->c, harq->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,harq->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];

openair1/PHY/NR_TRANSPORT/nr_scrambling.c

@@ -40,7 +40,7 @@ void nr_codeword_scrambling(uint8_t *in,
     __m256i c = ((__m256i*)in)[i];
     uint32_t in32 = _mm256_movemask_epi8(_mm256_slli_epi16(c,7));
     out[i]=(in32^s);
-    //printf("in[%d] %x => %x\n",i,in32,out[i]);
+    LOG_D(PHY,"in[%d] %x => %x\n",i,in32,out[i]);
     s=lte_gold_generic(&x1, &x2, 0);
   }
 #elif defined(__SSE4__)

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -106,7 +106,7 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
                               uint8_t abstraction_flag,
                               uint16_t N_RB);
 
-void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB);
+void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB, const NR_DL_FRAME_PARMS* frame_parms);
 
 /** \brief This function is the top-level entry point to PUSCH demodulation, after frequency-domain transformation and channel estimation.  It performs
     - RB extraction (signal and channel estimates)
@@ -146,7 +146,7 @@ void nr_ulsch_extract_rbs_single(int32_t **rxdataF,
 
 void nr_ulsch_scale_channel(int32_t **ul_ch_estimates_ext,
                             NR_DL_FRAME_PARMS *frame_parms,
-                            NR_gNB_ULSCH_t **ulsch_gNB,
+                            NR_gNB_ULSCH_t *ulsch_gNB,
                             uint8_t symbol,
                             uint8_t start_symbol,
                             uint16_t nb_rb,

openair1/PHY/NR_TRANSPORT/nr_ulsch.c

@@ -42,15 +42,14 @@ int16_t find_nr_ulsch(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type) {
   AssertFatal(gNB!=NULL,"gNB is null\n");
   for (i=0; i<gNB->number_of_nr_ulsch_max; i++) {
     AssertFatal(gNB->ulsch[i]!=NULL,"gNB->ulsch[%d] is null\n",i);
-    AssertFatal(gNB->ulsch[i][0]!=NULL,"gNB->ulsch[%d][0] is null\n",i);
-    LOG_D(PHY,"searching for rnti %x : ulsch_index %d=> harq_mask %x, rnti %x, first_free_index %d\n", rnti,i,gNB->ulsch[i][0]->harq_mask,gNB->ulsch[i][0]->rnti,first_free_index);
-    if ((gNB->ulsch[i][0]->harq_mask >0) &&
-        (gNB->ulsch[i][0]->rnti==rnti))       return i;
-    else if ((gNB->ulsch[i][0]->harq_mask == 0) && (first_free_index==-1)) first_free_index=i;
+    LOG_D(PHY,"searching for rnti %x : ulsch_index %d=> harq_mask %x, rnti %x, first_free_index %d\n", rnti,i,gNB->ulsch[i]->harq_mask,gNB->ulsch[i]->rnti,first_free_index);
+    if ((gNB->ulsch[i]->harq_mask >0) &&
+        (gNB->ulsch[i]->rnti==rnti))       return i;
+    else if ((gNB->ulsch[i]->harq_mask == 0) && (first_free_index==-1)) first_free_index=i;
   }
   if (type == SEARCH_EXIST) return -1;
   if (first_free_index != -1)
-    gNB->ulsch[first_free_index][0]->rnti = 0;
+    gNB->ulsch[first_free_index]->rnti = 0;
   return first_free_index;
 }
 
@@ -64,7 +63,7 @@ void nr_fill_ulsch(PHY_VARS_gNB *gNB,
   AssertFatal( (ulsch_id>=0) && (ulsch_id<gNB->number_of_nr_ulsch_max),
               "illegal or no ulsch_id found!!! rnti %04x ulsch_id %d\n",ulsch_pdu->rnti,ulsch_id);
 
-  NR_gNB_ULSCH_t  *ulsch = gNB->ulsch[ulsch_id][0];
+  NR_gNB_ULSCH_t  *ulsch = gNB->ulsch[ulsch_id];
   int harq_pid = ulsch_pdu->pusch_data.harq_process_id;
   ulsch->rnti = ulsch_pdu->rnti;
   //ulsch->rnti_type;

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -175,7 +175,7 @@ void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch)
         //t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_NR_ULSCH_SEGMENTS];
         ulsch->harq_processes[i]->Z=0;
         /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
-        //int16_t e[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+        //int16_t e[MAX_NUM_NR_ULSCH_SEGMENTS][3*8448];
         ulsch->harq_processes[i]->E=0;
 
 
@@ -406,7 +406,7 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 #endif
   
 
-  NR_gNB_ULSCH_t                       *ulsch                 = phy_vars_gNB->ulsch[ULSCH_id][0];
+  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_processes[harq_pid];
 
@@ -532,6 +532,12 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
                   &harq_process->F,
                   p_decParams->BG);
 
+  if (harq_process->C>MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*n_layers) {
+    LOG_E(PHY,"nr_segmentation.c: too many segments %d, B %d\n",harq_process->C,harq_process->B);
+    return(-1);
+  }
+
+
 #ifdef DEBUG_ULSCH_DECODING
   printf("ulsch decoding nr segmentation Z %d\n", harq_process->Z);
   if (!frame%100)

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -403,7 +403,7 @@ void nr_ulsch_extract_rbs_single(int32_t **rxdataF,
 
 void nr_ulsch_scale_channel(int **ul_ch_estimates_ext,
                             NR_DL_FRAME_PARMS *frame_parms,
-                            NR_gNB_ULSCH_t **ulsch_gNB,
+                            NR_gNB_ULSCH_t *ulsch_gNB,
                             uint8_t symbol,
                             uint8_t is_dmrs_symbol,
                             unsigned short nb_rb,
@@ -418,7 +418,7 @@ void nr_ulsch_scale_channel(int **ul_ch_estimates_ext,
 
   // Determine scaling amplitude based the symbol
 
-  ch_amp = 1024*8; //((pilots) ? (ulsch_gNB[0]->sqrt_rho_b) : (ulsch_gNB[0]->sqrt_rho_a));
+  ch_amp = 1024*8; //((pilots) ? (ulsch_gNB->sqrt_rho_b) : (ulsch_gNB->sqrt_rho_a));
 
   LOG_D(PHY,"Scaling PUSCH Chest in OFDM symbol %d by %d, pilots %d nb_rb %d NCP %d symbol %d\n", symbol, ch_amp, is_dmrs_symbol, nb_rb, frame_parms->Ncp, symbol);
    // printf("Scaling PUSCH Chest in OFDM symbol %d by %d\n",symbol_mod,ch_amp);
@@ -1177,7 +1177,7 @@ int nr_rx_pusch(PHY_VARS_gNB *gNB,
   int avgs = 0;
 
   NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
-  nfapi_nr_pusch_pdu_t *rel15_ul = &gNB->ulsch[ulsch_id][0]->harq_processes[harq_pid]->ulsch_pdu;
+  nfapi_nr_pusch_pdu_t *rel15_ul = &gNB->ulsch[ulsch_id]->harq_processes[harq_pid]->ulsch_pdu;
   int avg[frame_parms->nb_antennas_rx*rel15_ul->nrOfLayers];
 
   gNB->pusch_vars[ulsch_id]->dmrs_symbol = INVALID_VALUE;

openair1/PHY/NR_TRANSPORT/pucch_rx.c

@@ -457,7 +457,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB,
 
     uci_pdu->harq->harq_list[1].harq_value = !(index&0x01);
     uci_pdu->harq->harq_list[0].harq_value = !((index>>1)&0x01);
-    LOG_D(PHY, "[DLSCH/PDSCH/PUCCH] %d.%d HARQ values %d (0 pass, 1 fail) and %d with confidence level %d (0 is good, 1 is bad), xrt_mag %d xrt_mag_next %d n0 %d (%d,%d) pucch0_thres %d, cqi %d, SNRtimes10 %d,sync_pos %d\n",
+    LOG_D(PHY, "[DLSCH/PDSCH/PUCCH] %d.%d HARQ values %d and %d (0 pass, 1 fail) with confidence level %d (0 is good, 1 is bad), xrt_mag %d xrt_mag_next %d n0 %d (%d,%d) pucch0_thres %d, cqi %d, SNRtimes10 %d,sync_pos %d\n",
           frame,slot,uci_pdu->harq->harq_list[1].harq_value,uci_pdu->harq->harq_list[0].harq_value,uci_pdu->harq->harq_confidence_level,xrtmag_dBtimes10,xrtmag_next_dBtimes10,max_n0,uci_stats->pucch0_n00,uci_stats->pucch0_n01,uci_stats->pucch0_thres,cqi,SNRtimes10,gNB->ulsch_stats[0].sync_pos);
     if (pucch_pdu->sr_flag == 1) {
       uci_pdu->sr = calloc(1,sizeof(*uci_pdu->sr));

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -79,9 +79,11 @@ void init_dlsch_tpool(uint8_t num_dlsch_threads) {
   free(params);
 }
 
+
 void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr, uint16_t N_RB_DL) {
-  int i,r;
-  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*NR_MAX_NB_LAYERS;
+
   NR_UE_DLSCH_t *dlsch=*dlschptr;
 
   if (dlsch) {
@@ -90,36 +92,23 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr, uint16_t N_RB_DL) {
       a_segments = a_segments/273 +1;
     }
 
-    for (i=0; i<dlsch->Mdlharq; i++) {
+    for (int i=0; i<dlsch->Mdlharq; i++) {
       if (dlsch->harq_processes[i]) {
         if (dlsch->harq_processes[i]->b) {
           free16(dlsch->harq_processes[i]->b,a_segments*1056);
           dlsch->harq_processes[i]->b = NULL;
         }
 
-        for (r=0; r<a_segments; r++) {
+        for (int r=0; r<a_segments; r++) {
           free16(dlsch->harq_processes[i]->c[r],1056);
           dlsch->harq_processes[i]->c[r] = NULL;
+          free16(dlsch->harq_processes[i]->d[r],5*8448);
+          dlsch->harq_processes[i]->d[r] = NULL;
+          nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
         }
-
-        for (r=0; r<a_segments; r++)
-          if (dlsch->harq_processes[i]->d[r]) {
-            free16(dlsch->harq_processes[i]->d[r],(5*8448)*sizeof(short));
-            dlsch->harq_processes[i]->d[r] = NULL;
-          }
-
-        for (r=0; r<a_segments; r++)
-          if (dlsch->harq_processes[i]->w[r]) {
-            free16(dlsch->harq_processes[i]->w[r],(5*8448)*sizeof(short));
-            dlsch->harq_processes[i]->w[r] = NULL;
-          }
-
-        for (r=0; r<a_segments; r++) {
-          if (dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]) {
-            nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
-            dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
-          }
-        }
+        free16(dlsch->harq_processes[i]->c,a_segments);
+        free16(dlsch->harq_processes[i]->d,a_segments);
+        free16(dlsch->harq_processes[i]->p_nrLDPC_procBuf,a_segments);
 
         free16(dlsch->harq_processes[i],sizeof(NR_DL_UE_HARQ_t));
         dlsch->harq_processes[i] = NULL;
@@ -131,10 +120,13 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr, uint16_t N_RB_DL) {
   }
 }
 
+
 NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_ldpc_iterations,uint16_t N_RB_DL) {
+
   NR_UE_DLSCH_t *dlsch;
-  uint8_t exit_flag = 0,i,r;
-  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+  uint8_t exit_flag = 0;
+
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*NR_MAX_NB_LAYERS;  //number of segments to be allocated
 
   if (N_RB_DL != 273) {
     a_segments = a_segments*N_RB_DL;
@@ -153,7 +145,7 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
     dlsch->Mlimit = 4;
     dlsch->max_ldpc_iterations = max_ldpc_iterations;
 
-    for (i=0; i<Mdlharq; i++) {
+    for (int i=0; i<Mdlharq; i++) {
       dlsch->harq_processes[i] = (NR_DL_UE_HARQ_t *)malloc16(sizeof(NR_DL_UE_HARQ_t));
 
       if (dlsch->harq_processes[i]) {
@@ -167,26 +159,17 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
         else
           exit_flag=3;
 
-        for (r=0; r<a_segments; r++) {
+        dlsch->harq_processes[i]->c = (uint8_t **)malloc16(a_segments*sizeof(uint8_t *));
+        dlsch->harq_processes[i]->d = (int16_t **)malloc16(a_segments*sizeof(int16_t *));
+        dlsch->harq_processes[i]->p_nrLDPC_procBuf = (t_nrLDPC_procBuf **)malloc16(a_segments*sizeof(t_nrLDPC_procBuf *));
+        for (int r=0; r<a_segments; r++) {
           dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
           dlsch->harq_processes[i]->c[r] = (uint8_t *)malloc16(1056);
-
+          dlsch->harq_processes[i]->d[r] = (int16_t *)malloc16(5*8448*sizeof(int16_t));
           if (dlsch->harq_processes[i]->c[r])
             memset(dlsch->harq_processes[i]->c[r],0,1056);
-          else
-            exit_flag=2;
-
-          dlsch->harq_processes[i]->d[r] = (short *)malloc16((5*8448)*sizeof(short));
-
           if (dlsch->harq_processes[i]->d[r])
-            memset(dlsch->harq_processes[i]->d[r],0,(5*8448)*sizeof(short));
-          else
-            exit_flag=2;
-
-          dlsch->harq_processes[i]->w[r] = (short *)malloc16((5*8448)*sizeof(short));
-
-          if (dlsch->harq_processes[i]->w[r])
-            memset(dlsch->harq_processes[i]->w[r],0,(5*8448)*sizeof(short));
+            memset(dlsch->harq_processes[i]->d[r],0,5*8448);
           else
             exit_flag=2;
         }
@@ -320,11 +303,16 @@ void nr_processDLSegment(void* arg) {
 
   t_nrLDPC_procBuf **p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf;
 
+
+    int16_t w[5*8448];
+    memset(w,0,(5*8448)*sizeof(short));
+
     start_meas(&rdata->ts_deinterleave);
+
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DEINTERLEAVING, VCD_FUNCTION_IN);
     nr_deinterleaving_ldpc(E,
                            Qm,
-                           harq_process->w[r], // [hna] w is e
+                           w, // [hna] w is e
                            dlsch_llr+r_offset);
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DEINTERLEAVING, VCD_FUNCTION_OUT);
     stop_meas(&rdata->ts_deinterleave);
@@ -346,7 +334,7 @@ void nr_processDLSegment(void* arg) {
                                  p_decoderParms->BG,
                                  p_decoderParms->Z,
                                  harq_process->d[r],
-                                 harq_process->w[r],
+                                 w,
                                  harq_process->C,
                                  harq_process->rvidx,
                                  (harq_process->first_rx==1)?1:0,
@@ -578,6 +566,11 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                     &harq_process->F,
                     p_decParams->BG);
 
+    if (harq_process->C>MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*harq_process->Nl) {
+      LOG_E(PHY,"nr_segmentation.c: too many segments %d, B %d\n",harq_process->C,harq_process->B);
+      return(-1);
+    }
+
     if (LOG_DEBUGFLAG(DEBUG_DLSCH_DECOD) && (!frame%100))
       LOG_I(PHY,"K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
   }
@@ -593,7 +586,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   p_decParams->numMaxIter = dlsch->max_ldpc_iterations;
   p_decParams->outMode= 0;
   r_offset = 0;
-  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*harq_process->Nl;  //number of segments to be allocated
 
   if (nb_rb != 273) {
     a_segments = a_segments*nb_rb;

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -202,7 +202,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     pdsch_vars = ue->pdsch_vars[proc->thread_id];
     dlsch = ue->dlsch[proc->thread_id][gNB_id];
     dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
-    dlsch1_harq = dlsch[1]->harq_processes[harq_pid];
+    if (NR_MAX_NB_LAYERS>4)
+      dlsch1_harq = dlsch[1]->harq_processes[harq_pid];
     beamforming_mode = ue->transmission_mode[gNB_id] < 7 ? 0 :ue->transmission_mode[gNB_id];
     break;
 

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -88,9 +88,9 @@ typedef struct {
   /// LDPC-code outputs
   uint8_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
   /// LDPC-code outputs (TS 36.212 V15.4.0, Sec 5.3.2 p. 17)
-  uint8_t *e; 
+  uint8_t *e;
   /// Rate matching (Interleaving) outputs (TS 36.212 V15.4.0, Sec 5.4.2.2 p. 30)
-  uint8_t *f; 
+  uint8_t *f;
   /// Number of code segments
   uint32_t C;
   /// Number of bits in code segments
@@ -122,55 +122,15 @@ typedef struct {
 typedef struct {
   /// SRS active flag
   uint8_t srs_active; 
-//#if defined(UPGRADE_RAT_NR)
-#if 1
   // Pointers to HARQ processes for the ULSCH
   NR_UL_UE_HARQ_t *harq_processes[NR_MAX_ULSCH_HARQ_PROCESSES];
   int harq_process_id[NR_MAX_SLOTS_PER_FRAME];
   // UL number of harq processes
   uint8_t number_harq_processes_for_pusch;
-#endif 
-  /*
-  /// Pointer to CQI data (+1 for 8 bits crc)
-  uint8_t o[1+MAX_CQI_BYTES];
-  /// Length of CQI data (bits)
-  uint8_t O;
-  /// Format of CQI data
-  UCI_format_t uci_format;
-  /// Rank information
-  uint8_t o_RI[2];
-  /// Length of rank information (bits)
-  uint8_t O_RI;
-  /// Pointer to ACK
-  uint8_t o_ACK[4];
-  */
   /// Minimum number of CQI bits for PUSCH (36-212 r8.6, Sec 5.2.4.1 p. 37)
   uint8_t O_CQI_MIN;
   /// ACK/NAK Bundling flag
   uint8_t bundling;
-  /// Concatenated "g"-sequences (for definition see 36-212 V15.4.0 2018-12, p.31)
-  uint8_t g[MAX_NUM_NR_CHANNEL_BITS] __attribute__ ((aligned(32)));
-  /// Interleaved "h"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
-  uint8_t h[MAX_NUM_NR_CHANNEL_BITS];
-  /// Scrambled "b"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  uint8_t b_tilde[MAX_NUM_NR_CHANNEL_BITS];
-  /// Modulated "d"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  int32_t d_mod[MAX_NUM_NR_RE] __attribute__ ((aligned(16)));
-  /// Transform-coded "y"-sequences (for definition see 38-211 V15.3.0 2018-09, subsection 6.3.1.4)
-  int32_t y[MAX_NUM_NR_RE] __attribute__ ((aligned(16)));
-  /*
-  /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
-  uint8_t q[MAX_CQI_PAYLOAD];
-  
-  /// coded and interleaved CQI bits
-  uint8_t o_w[(MAX_CQI_BITS+8)*3];
-  /// coded CQI bits
-  uint8_t o_d[96+((MAX_CQI_BITS+8)*3)];
-  /// coded ACK bits
-  uint8_t q_ACK[MAX_ACK_PAYLOAD];
-  /// coded RI bits
-  uint8_t q_RI[MAX_RI_PAYLOAD];
-  */
   /// beta_offset_cqi times 8
   uint16_t beta_offset_cqi_times8;
   /// beta_offset_ri times 8
@@ -219,7 +179,9 @@ typedef struct {
   /// Pointer to the payload
   uint8_t *b;
   /// Pointers to transport block segments
-  uint8_t *c[MAX_NUM_NR_DLSCH_SEGMENTS];
+  uint8_t **c;
+  /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  int16_t **d;
   /// Index of current HARQ round for this DLSCH
   uint8_t round;
   /// MCS table for this DLSCH
@@ -234,14 +196,8 @@ typedef struct {
   uint8_t rvidx;
   /// MIMO mode for this DLSCH
   MIMO_nrmode_t mimo_mode;
-  /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  int16_t *w[MAX_NUM_NR_DLSCH_SEGMENTS];
-  /// for abstraction soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  //double w_abs[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
-  /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  int16_t *d[MAX_NUM_NR_DLSCH_SEGMENTS];
   /// LDPC processing buffers
-  t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_NR_DLSCH_SEGMENTS];
+  t_nrLDPC_procBuf **p_nrLDPC_procBuf;
   /// Number of code segments 
   uint32_t C;
   /// Number of bits in code segments

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -174,43 +174,23 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
                       unsigned int G)
 {
   start_meas(&ue->ulsch_encoding_stats);
-/////////////////////////parameters and variables declaration/////////////////////////
-///////////
-
-  unsigned int crc;
-  NR_UL_UE_HARQ_t *harq_process; 
-  uint16_t nb_rb ;
-  uint32_t A, F;
-  uint32_t *pz; 
-  uint8_t mod_order; 
-  uint16_t Kr,r;
-  uint32_t r_offset;
-  uint32_t E,Kb;
-  uint8_t Ilbrm; 
-  uint32_t Tbslbrm; 
-  uint16_t R;
-  float Coderate;
-
-///////////
-///////////////////////////////////////////////////////////////////////////////////////
-
 
 /////////////////////////parameters and variables initialization/////////////////////////
 ///////////
 
-  crc = 1;
-  harq_process = ulsch->harq_processes[harq_pid];
-  nb_rb = harq_process->pusch_pdu.rb_size;
-  A = harq_process->pusch_pdu.pusch_data.tb_size*8;
-  pz = &harq_process->Z;
-  mod_order = nr_get_Qm_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
-  R = nr_get_code_rate_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
-  Kr=0;
-  r_offset=0;
-  F=0;
-  Ilbrm = 0;
-  Tbslbrm = 950984; //max tbs
-  Coderate = 0.0;
+  unsigned int crc = 1;
+  NR_UL_UE_HARQ_t *harq_process = ulsch->harq_processes[harq_pid];
+  uint16_t nb_rb = harq_process->pusch_pdu.rb_size;
+  uint32_t A = harq_process->pusch_pdu.pusch_data.tb_size*8;
+  uint32_t *pz = &harq_process->Z;
+  uint8_t mod_order = nr_get_Qm_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
+  uint16_t R = nr_get_code_rate_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
+  uint16_t Kr=0;
+  uint32_t r_offset=0;
+  uint32_t F=0;
+  uint8_t Ilbrm = 0;
+  uint32_t Tbslbrm = 950984; //max tbs
+  float Coderate = 0.0;
 ///////////
 /////////////////////////////////////////////////////////////////////////////////////////  
 
@@ -286,14 +266,19 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_SEGMENTATION, VCD_FUNCTION_IN);
     start_meas(&ue->ulsch_segmentation_stats);
-    Kb=nr_segmentation(harq_process->b,
-                       harq_process->c,
-                       harq_process->B,
-                       &harq_process->C,
-                       &harq_process->K,
-                       pz,
-                       &harq_process->F,
-                       harq_process->BG);
+    uint32_t  Kb=nr_segmentation(harq_process->b,
+                                 harq_process->c,
+                                 harq_process->B,
+                                 &harq_process->C,
+                                 &harq_process->K,
+                                 pz,
+                                 &harq_process->F,
+                                 harq_process->BG);
+
+    if (harq_process->C>MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*harq_process->pusch_pdu.nrOfLayers) {
+      LOG_E(PHY,"nr_segmentation.c: too many segments %d, B %d\n",harq_process->C,harq_process->B);
+      return(-1);
+    }
     stop_meas(&ue->ulsch_segmentation_stats);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_SEGMENTATION, VCD_FUNCTION_OUT);
 
@@ -310,7 +295,7 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     //printf("segment Z %d k %d Kr %d BG %d\n", *pz,harq_process->K,Kr,BG);
 
     //start_meas(te_stats);
-    for (r=0; r<harq_process->C; r++) {
+    for (int r=0; r<harq_process->C; r++) {
       //channel_input[r] = &harq_process->d[r][0];
 #ifdef DEBUG_ULSCH_CODING
       printf("Encoder: B %d F %d \n",harq_process->B, harq_process->F);
@@ -345,8 +330,7 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_IN);
 
     start_meas(&ue->ulsch_ldpc_encoding_stats);
-    for(int j = 0; j < (harq_process->C/8 + 1); j++)
-    {
+    for(int j = 0; j < (harq_process->C/8 + 1); j++) {
       impp.macro_num = j;
       nrLDPC_encoder(harq_process->c,harq_process->d,*pz,Kb,Kr,harq_process->BG,&impp);
     }
@@ -369,14 +353,13 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
   F = harq_process->F;
   Kr = harq_process->K;
 
-  for (r=0; r<harq_process->C; r++) { // looping over C segments
-
+  for (int r=0; r<harq_process->C; r++) { // looping over C segments
     if (harq_process->F>0) {
-            for (int k=(Kr-F-2*(*pz)); k<Kr-2*(*pz); k++) {
-              harq_process->d[r][k] = NR_NULL;
-              //if (k<(Kr-F+8))
-              //printf("r %d filler bits [%d] = %d \n", r,k, harq_process->d[r][k]);
-            }
+      for (int k=(Kr-F-2*(*pz)); k<Kr-2*(*pz); k++) {
+        harq_process->d[r][k] = NR_NULL;
+        //if (k<(Kr-F+8))
+        //printf("r %d filler bits [%d] = %d \n", r,k, harq_process->d[r][k]);
+      }
     }
 
 
@@ -391,7 +374,7 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
 ///////////////////////// d---->| Rate matching bit selection |---->e /////////////////////////
 ///////////
 
-    E = nr_get_E(G, harq_process->C, mod_order, harq_process->pusch_pdu.nrOfLayers, r);
+    uint32_t E = nr_get_E(G, harq_process->C, mod_order, harq_process->pusch_pdu.nrOfLayers, r);
 
     Tbslbrm = nr_compute_tbslbrm(0,nb_rb,harq_process->pusch_pdu.nrOfLayers);
 
@@ -434,9 +417,9 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     
     start_meas(&ue->ulsch_interleaving_stats);
     nr_interleaving_ldpc(E,
-            mod_order,
-            harq_process->e+r_offset,
-            harq_process->f+r_offset);
+                         mod_order,
+                         harq_process->e+r_offset,
+                         harq_process->f+r_offset);
     stop_meas(&ue->ulsch_interleaving_stats);
     
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INTERLEAVING_LDPC, VCD_FUNCTION_OUT);
@@ -458,8 +441,6 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
 
   }
 
-  memcpy(ulsch->g,harq_process->f,G); // g is the concatenated code block
-
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_UE_ULSCH_ENCODING, VCD_FUNCTION_OUT);
 
   stop_meas(&ue->ulsch_encoding_stats);

openair1/PHY/defs_gNB.h

@@ -89,7 +89,7 @@ typedef struct {
   /// Pointer to the payload
   uint8_t *b;
   /// Pointers to transport block segments
-  uint8_t *c[MAX_NUM_NR_DLSCH_SEGMENTS];
+  uint8_t **c;
   /// Frame where current HARQ round was sent
   uint32_t frame;
   /// Subframe where current HARQ round was sent
@@ -157,13 +157,11 @@ typedef struct {
   /// Pointers to variables related to DLSCH harq process
   NR_DL_gNB_HARQ_t harq_process;
   /// TX buffers for UE-spec transmission (antenna layers 1,...,4 after to precoding)
-  int32_t *txdataF[NR_MAX_NB_LAYERS];
-  /// TX buffers for UE-spec transmission (antenna ports 1000 or 1001,...,1007, before precoding)
-  int32_t *txdataF_precoding[NR_MAX_NB_LAYERS];
+  int32_t **txdataF;
   /// Modulated symbols buffer
-  int32_t *mod_symbs[NR_MAX_NB_CODEWORDS];
+  int32_t **mod_symbs;
   /// beamforming weights for UE-spec transmission (antenna ports 5 or 7..14), for each codeword, maximum 4 layers?
-  int32_t **ue_spec_bf_weights[NR_MAX_NB_LAYERS];
+  int32_t ***ue_spec_bf_weights;
   /// dl channel estimates (estimated from ul channel estimates)
   int32_t **calib_dl_ch_estimates;
   /// Allocated RNTI (0 means DLSCH_t is not currently used)
@@ -287,7 +285,7 @@ typedef struct {
   /// LDPC lifting size (38.212 V15.4.0 table 5.3.2-1)
   uint32_t Z;
   /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
-  int16_t e[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+  int16_t e[MAX_NUM_NR_ULSCH_SEGMENTS][3*8448];
   /// Number of bits in each code block after rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
   uint32_t E;
   /// Number of segments processed so far
@@ -771,7 +769,7 @@ typedef struct PHY_VARS_gNB_s {
   NR_gNB_PDCCH_t     pdcch_pdu[NUMBER_OF_NR_PDCCH_MAX];
   NR_gNB_UL_PDCCH_t  ul_pdcch_pdu[NUMBER_OF_NR_PDCCH_MAX];
   NR_gNB_DLSCH_t     *dlsch[NUMBER_OF_NR_DLSCH_MAX][2];    // Nusers times two spatial streams
-  NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_NR_ULSCH_MAX][2];  // [Nusers times][2 codewords] 
+  NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_NR_ULSCH_MAX];  // [Nusers times]
   NR_gNB_DLSCH_t     *dlsch_SI,*dlsch_ra,*dlsch_p;
   NR_gNB_DLSCH_t     *dlsch_PCH;
   /// statistics for DLSCH measurement collection

openair1/PHY/defs_nr_UE.h

@@ -225,11 +225,6 @@ typedef struct {
 
 } NR_UE_COMMON_PER_THREAD;
 
-typedef struct {
-  /// TX buffers for multiple layers
-  int32_t *txdataF_layers[NR_MAX_NB_LAYERS];
-  } NR_UE_PUSCH;
-
 typedef struct {
   bool active[2];
   fapi_nr_ul_config_pucch_pdu pucch_pdu[2];
@@ -785,10 +780,9 @@ typedef struct {
   NR_UE_PDCCH     *pdcch_vars[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_PRACH     *prach_vars[NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_SRS       *srs_vars[NUMBER_OF_CONNECTED_gNB_MAX];
-  NR_UE_PUSCH     *pusch_vars[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_PUCCH     *pucch_vars[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX];
-  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX][NR_MAX_NB_CODEWORDS]; // two RxTx Threads
-  NR_UE_ULSCH_t   *ulsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX][NR_MAX_NB_CODEWORDS]; // two code words
+  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX][NR_MAX_NB_LAYERS>4 ? 2:1]; // two RxTx Threads
+  NR_UE_ULSCH_t   *ulsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_DLSCH_t   *dlsch_SI[NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_DLSCH_t   *dlsch_ra[NUMBER_OF_CONNECTED_gNB_MAX];
   NR_UE_DLSCH_t   *dlsch_p[NUMBER_OF_CONNECTED_gNB_MAX];
@@ -832,7 +826,7 @@ typedef struct {
   uint16_t scramblingID_pdcch;
 
   /// PUSCH DMRS sequence
-  uint32_t ****nr_gold_pusch_dmrs;
+  uint32_t ***nr_gold_pusch_dmrs;
 
   uint32_t X_u[64][839];
 

openair1/PHY/defs_nr_common.h

@@ -44,8 +44,6 @@
 
 #define MAX_NUM_SUBCARRIER_SPACING 5
 
-#define NR_MAX_NB_RB 275
-
 #define NR_NB_SC_PER_RB 12
 #define NR_NB_REG_PER_CCE 6
 
@@ -67,22 +65,9 @@
 #define NR_PBCH_DMRS_LENGTH 144 // in mod symbols
 #define NR_PBCH_DMRS_LENGTH_DWORD 10 // ceil(2(QPSK)*NR_PBCH_DMRS_LENGTH/32)
 
-/*These max values are for the gold sequences which are generated at init for the
- * full carrier bandwidth*/
-#define NR_MAX_PDCCH_DMRS_INIT_LENGTH ((NR_MAX_NB_RB<<1)*3) // 3 symbols *2(QPSK)
-#define NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD 52 // ceil(NR_MAX_PDCCH_DMRS_LENGTH/32)
 /*used for the resource mapping*/
 #define NR_MAX_PDCCH_DMRS_LENGTH 576 // 16(L)*2(QPSK)*3(3 DMRS symbs per REG)*6(REG per CCE)
 
-#define NR_MAX_PDSCH_DMRS_LENGTH 3300      //275*6(k)*2(QPSK real+imag) 
-#define NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD 104  // ceil(NR_MAX_PDSCH_DMRS_LENGTH/32)
-
-#define NR_MAX_CSI_RS_LENGTH 4400 //275*8(max allocation per RB)*2(QPSK)
-#define NR_MAX_CSI_RS_INIT_LENGTH_DWORD 138  // ceil(NR_MAX_CSI_RS_LENGTH/32)
-
-#define NR_MAX_PUSCH_DMRS_LENGTH NR_MAX_PDSCH_DMRS_LENGTH 
-#define NR_MAX_PUSCH_DMRS_INIT_LENGTH_DWORD NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD
-
 #define NR_MAX_DCI_PAYLOAD_SIZE 64
 #define NR_MAX_DCI_SIZE 1728 //16(L)*2(QPSK)*9(12 RE per REG - 3(DMRS))*6(REG per CCE)
 #define NR_MAX_DCI_SIZE_DWORD 54 // ceil(NR_MAX_DCI_SIZE/32)
@@ -93,24 +78,19 @@
 #define NR_MAX_CSET_DURATION 3
 
 #define NR_MAX_NB_RBG 18
-#define NR_MAX_NB_LAYERS 2 // 8 // SU-MIMO (3GPP TS 38.211 V15.4.0 section 7.3.1.3)
-#define NR_MAX_NB_CODEWORDS 2
+#define NR_MAX_NB_LAYERS 4 // 8
 #define NR_MAX_NB_HARQ_PROCESSES 16
-#define NR_MAX_PDSCH_ENCODED_LENGTH (NR_MAX_NB_RB*NR_SYMBOLS_PER_SLOT*NR_NB_SC_PER_RB*8*NR_MAX_NB_LAYERS) // 8 is the maximum modulation order (it was 950984 before !!)
-#define NR_MAX_PUSCH_ENCODED_LENGTH NR_MAX_PDSCH_ENCODED_LENGTH
+
 #define NR_MAX_PDSCH_TBS 3824
 #define NR_MAX_SIB_LENGTH 2976 // 3GPP TS 38.331 section 5.2.1 - The physical layer imposes a limit to the maximum size a SIB can take. The maximum SIB1 or SI message size is 2976 bits.
 
-#define MAX_NUM_NR_DLSCH_SEGMENTS (NR_MAX_NB_LAYERS*34)
-#define MAX_NR_DLSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
+#define MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER 34
 
 #define MAX_NUM_NR_ULSCH_SEGMENTS 34
 #define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_ULSCH_SEGMENTS*1056)
 
 #define MAX_NUM_NR_SRS_SYMBOLS 4
 
-#define MAX_NUM_NR_CHANNEL_BITS (14*273*12*8)  // 14 symbols, 273 RB
-#define MAX_NUM_NR_RE (14*273*12)
 #define NR_RX_NB_TH 1
 #define NR_NB_TH_SLOT 2
 
@@ -253,7 +233,7 @@ typedef struct {
 
 typedef struct {
   uint16_t sc_list_length;
-  uint16_t sc_list[6 * NR_MAX_NB_RB];
+  uint16_t *sc_list;
   uint8_t srs_generated_signal_bits;
   int32_t *srs_generated_signal;
   int32_t **srs_received_signal;

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -198,7 +198,7 @@ void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req) {
   NR_UL_gNB_HARQ_t *ulsch_harq = rdata->ulsch_harq;
   NR_gNB_ULSCH_t *ulsch = rdata->ulsch;
   int r = rdata->segment_r;
-  nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[rdata->ulsch_id][0]->harq_processes[rdata->harq_pid]->ulsch_pdu;
+  nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[rdata->ulsch_id]->harq_processes[rdata->harq_pid]->ulsch_pdu;
 
   bool decodeSuccess = (rdata->decodeIterations <= rdata->decoderParms.numMaxIter);
   ulsch_harq->processedSegments++;
@@ -303,7 +303,7 @@ void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req) {
 void 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;
-  nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[ULSCH_id][0]->harq_processes[harq_pid]->ulsch_pdu;
+  nfapi_nr_pusch_pdu_t *pusch_pdu = &gNB->ulsch[ULSCH_id]->harq_processes[harq_pid]->ulsch_pdu;
   
   uint8_t l, number_dmrs_symbols = 0;
   uint32_t G;
@@ -379,13 +379,13 @@ void nr_fill_indication(PHY_VARS_gNB *gNB, int frame, int slot_rx, int ULSCH_id,
 
   pthread_mutex_lock(&gNB->UL_INFO_mutex);
 
-  NR_gNB_ULSCH_t                       *ulsch                 = gNB->ulsch[ULSCH_id][0];
+  NR_gNB_ULSCH_t                       *ulsch                 = gNB->ulsch[ULSCH_id];
   NR_UL_gNB_HARQ_t                     *harq_process          = ulsch->harq_processes[harq_pid];
   NR_gNB_SCH_STATS_t *stats=get_ulsch_stats(gNB,ulsch);
 
   nfapi_nr_pusch_pdu_t *pusch_pdu = &harq_process->ulsch_pdu;
 
-  //  pdu->data                              = gNB->ulsch[ULSCH_id+1][0]->harq_processes[harq_pid]->b;
+  //  pdu->data                              = gNB->ulsch[ULSCH_id+1]->harq_processes[harq_pid]->b;
   int sync_pos = nr_est_timing_advance_pusch(gNB, ULSCH_id); // estimate timing advance for MAC
 
   // scale the 16 factor in N_TA calculation in 38.213 section 4.2 according to the used FFT size
@@ -548,7 +548,7 @@ void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
   }
 
   for (int ULSCH_id=0;ULSCH_id<gNB->number_of_nr_ulsch_max;ULSCH_id++) {
-    NR_gNB_ULSCH_t *ulsch = gNB->ulsch[ULSCH_id][0];
+    NR_gNB_ULSCH_t *ulsch = gNB->ulsch[ULSCH_id];
     int harq_pid;
     NR_UL_gNB_HARQ_t *ulsch_harq;
     if ((ulsch) &&
@@ -708,7 +708,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
   }
 
   for (int ULSCH_id=0;ULSCH_id<gNB->number_of_nr_ulsch_max;ULSCH_id++) {
-    NR_gNB_ULSCH_t *ulsch = gNB->ulsch[ULSCH_id][0];
+    NR_gNB_ULSCH_t *ulsch = gNB->ulsch[ULSCH_id];
     int harq_pid;
     int no_sig;
     NR_UL_gNB_HARQ_t *ulsch_harq;

openair1/SCHED_NR_UE/fapi_nr_ue_l1.c

@@ -280,7 +280,7 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
     thread_id = scheduled_response->thread_id;
     NR_UE_DLSCH_t *dlsch0 = NULL;
     NR_UE_PDCCH *pdcch_vars = PHY_vars_UE_g[module_id][cc_id]->pdcch_vars[thread_id][0];
-    NR_UE_ULSCH_t *ulsch0 = PHY_vars_UE_g[module_id][cc_id]->ulsch[thread_id][0][0];
+    NR_UE_ULSCH_t *ulsch = PHY_vars_UE_g[module_id][cc_id]->ulsch[thread_id][0];
     NR_UE_PUCCH *pucch_vars = PHY_vars_UE_g[module_id][cc_id]->pucch_vars[thread_id][0];
 
     if(scheduled_response->dl_config != NULL){
@@ -367,7 +367,7 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
           // pusch config pdu
           pusch_config_pdu = &ul_config->ul_config_list[i].pusch_config_pdu;
           current_harq_pid = pusch_config_pdu->pusch_data.harq_process_id;
-          NR_UL_UE_HARQ_t *harq_process_ul_ue = ulsch0->harq_processes[current_harq_pid];
+          NR_UL_UE_HARQ_t *harq_process_ul_ue = ulsch->harq_processes[current_harq_pid];
           harq_process_ul_ue->status = 0;
 
           if (harq_process_ul_ue){
@@ -376,7 +376,7 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
 
             memcpy(pusch_pdu, pusch_config_pdu, sizeof(nfapi_nr_ue_pusch_pdu_t));
 
-            ulsch0->f_pusch = pusch_config_pdu->absolute_delta_PUSCH;
+            ulsch->f_pusch = pusch_config_pdu->absolute_delta_PUSCH;
 
             if (scheduled_response->tx_request) {
               for (int j=0; j<scheduled_response->tx_request->number_of_pdus; j++) {

openair1/SCHED_NR_UE/harq_nr.c

@@ -123,7 +123,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, i
 
     memset(ulsch,0,sizeof(NR_UE_ULSCH_t));
 
-    ue->ulsch[thread_id][gNB_id][code_word_idx] = ulsch;
+    ue->ulsch[thread_id][gNB_id] = ulsch;
   }
   else {
     LOG_E(PHY, "Fatal memory allocation problem at line %d in function %s of file %s \n", __LINE__ , __func__, __FILE__);
@@ -148,7 +148,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, i
   }
 
   for (int slot_tx = 0; slot_tx < NR_MAX_SLOTS_PER_FRAME; slot_tx++) {
-    ue->ulsch[thread_id][gNB_id][code_word_idx]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
+    ue->ulsch[thread_id][gNB_id]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
   }
 }
 
@@ -167,7 +167,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, i
 
 void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx)
 {
-  NR_UE_ULSCH_t *ulsch = ue->ulsch[thread_id][gNB_id][code_word_idx];
+  NR_UE_ULSCH_t *ulsch = ue->ulsch[thread_id][gNB_id];
 
   for (int process_id = 0; process_id < ulsch->number_harq_processes_for_pusch; process_id++) {
 
@@ -178,7 +178,7 @@ void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id,
 
   free16(ulsch, sizeof(NR_UE_ULSCH_t));
 
-  ue->ulsch[thread_id][gNB_id][code_word_idx] = NULL;
+  ue->ulsch[thread_id][gNB_id] = NULL;
 }
 
 /*******************************************************************

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -289,8 +289,9 @@ void phy_procedures_nrUE_TX(PHY_VARS_NR_UE *ue,
   start_meas(&ue->phy_proc_tx);
 
   if (ue->UE_mode[gNB_id] <= PUSCH){
-    for (uint8_t harq_pid = 0; harq_pid < ue->ulsch[proc->thread_id][gNB_id][0]->number_harq_processes_for_pusch; harq_pid++) {
-      if (ue->ulsch[proc->thread_id][gNB_id][0]->harq_processes[harq_pid]->status == ACTIVE)
+
+    for (uint8_t harq_pid = 0; harq_pid < ue->ulsch[proc->thread_id][gNB_id]->number_harq_processes_for_pusch; harq_pid++) {
+      if (ue->ulsch[proc->thread_id][gNB_id]->harq_processes[harq_pid]->status == ACTIVE)
         nr_ue_ulsch_procedures(ue, harq_pid, frame_tx, slot_tx, proc->thread_id, gNB_id);
     }
   }
@@ -1627,13 +1628,17 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
 
     start_meas(&ue->dlsch_procedures_stat[proc->thread_id]);
 
+    NR_UE_DLSCH_t *dlsch1 = NULL;
+    if (NR_MAX_NB_LAYERS>4)
+      dlsch1 = ue->dlsch[proc->thread_id][gNB_id][1];
+
     if (ret_pdsch >= 0)
       nr_ue_dlsch_procedures(ue,
 			   proc,
 			   gNB_id,
 			   PDSCH,
 			   ue->dlsch[proc->thread_id][gNB_id][0],
-			   ue->dlsch[proc->thread_id][gNB_id][1],
+			   dlsch1,
 			   &ue->dlsch_errors[gNB_id]);
 
   stop_meas(&ue->dlsch_procedures_stat[proc->thread_id]);

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -395,19 +395,6 @@ int main(int argc, char **argv)
 		load_pbch_desc(pbch_file_fd);
 	}
 
-	/*  for (int k=0; k<2; k++) {
-	 // Create transport channel structures for 2 transport blocks (MIMO)
-	 for (i=0; i<2; i++) {
-	 gNB->dlsch[k][i] = new_gNB_dlsch(Kmimo,8,Nsoft,0,frame_parms,gNB_config);
-
-	 if (!gNB->dlsch[k][i]) {
-	 printf("Can't get eNB dlsch structures\n");
-	 exit(-1);
-	 }
-	 gNB->dlsch[k][i]->Nsoft = 10;
-	 gNB->dlsch[k][i]->rnti = n_rnti+k;
-	 }
-	 }*/
 	//configure UE
 	UE = malloc(sizeof(PHY_VARS_NR_UE));
 	memcpy(&UE->frame_parms, frame_parms, sizeof(NR_DL_FRAME_PARMS));
@@ -420,10 +407,10 @@ int main(int argc, char **argv)
 
 	//nr_init_frame_parms_ue(&UE->frame_parms);
 	//init_nr_ue_transport(UE, 0);
+        int num_codeword = NR_MAX_NB_LAYERS > 4? 2:1;
 	for (int sf = 0; sf < 2; sf++) {
-		for (i = 0; i < 2; i++) {
+		for (i = 0; i < num_codeword; i++) {
 			UE->dlsch[sf][0][i] = new_nr_ue_dlsch(Kmimo, 8, Nsoft, 5, N_RB_DL);
-
 			if (!UE->dlsch[sf][0][i]) {
 				printf("Can't get ue dlsch structures\n");
 				exit(-1);
@@ -434,8 +421,8 @@ int main(int argc, char **argv)
 	}
 
 	unsigned char harq_pid = 0; //dlsch->harq_ids[subframe];
-  processingData_L1tx_t msgDataTx;
-  init_DLSCH_struct(gNB, &msgDataTx);
+        processingData_L1tx_t msgDataTx;
+        init_DLSCH_struct(gNB, &msgDataTx);
 	NR_gNB_DLSCH_t *dlsch = msgDataTx.dlsch[0][0];
 	nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->harq_process.pdsch_pdu.pdsch_pdu_rel15;
 	//time_stats_t *rm_stats, *te_stats, *i_stats;
@@ -642,8 +629,9 @@ int main(int argc, char **argv)
   free(RC.gNB[0]);
   free(RC.gNB);
 
+  int num_cw = NR_MAX_NB_LAYERS > 4? 2:1;
   for (int sf = 0; sf < 2; sf++)
-    for (int i = 0; i < 2; i++)
+    for (int i = 0; i < num_cw; i++)
       free_nr_ue_dlsch(&UE->dlsch[sf][0][i], N_RB_DL);
   term_nr_ue_signal(UE, 1);
   free(UE);

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -656,7 +656,7 @@ int main(int argc, char **argv)
       printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n",
              argv[0]);
       printf("-h This message\n");
-      printf("-L <log level, 0(errors), 1(warning), 2(info) 3(debug) 4 (trace)>\n");  
+      printf("-L <log level, 0(errors), 1(warning), 2(analysis), 3(info), 4(debug), 5(trace)>\n");
       //printf("-p Use extended prefix mode\n");
       //printf("-d Use TDD\n");
       printf("-n Number of frames to simulate\n");
@@ -1110,7 +1110,7 @@ int main(int argc, char **argv)
                             pdsch_pdu_rel15->dlDmrsSymbPos);
           ptrsSymbPerSlot = get_ptrs_symbols_in_slot(dlPtrsSymPos, pdsch_pdu_rel15->StartSymbolIndex, pdsch_pdu_rel15->NrOfSymbols);
           ptrsRePerSymb = ((rel15->rbSize + rel15->PTRSFreqDensity - 1)/rel15->PTRSFreqDensity);
-          printf("[DLSIM] PTRS Symbols in a slot: %2u, RE per Symbol: %3u, RE in a slot %4d\n", ptrsSymbPerSlot,ptrsRePerSymb, ptrsSymbPerSlot*ptrsRePerSymb );
+          LOG_D(PHY,"[DLSIM] PTRS Symbols in a slot: %2u, RE per Symbol: %3u, RE in a slot %4d\n", ptrsSymbPerSlot,ptrsRePerSymb, ptrsSymbPerSlot*ptrsRePerSymb );
         }
 
         msgDataTx->ssb[0].ssb_pdu.ssb_pdu_rel15.bchPayload=0x001234;
@@ -1267,7 +1267,7 @@ int main(int argc, char **argv)
       available_bits = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, mod_order, rel15->nrOfLayers);
       if(pdu_bit_map & 0x1) {
         available_bits-= (ptrsSymbPerSlot * ptrsRePerSymb *rel15->nrOfLayers* 2);
-        printf("[DLSIM][PTRS] Available bits are: %5u, removed PTRS bits are: %5u \n",available_bits, (ptrsSymbPerSlot * ptrsRePerSymb *rel15->nrOfLayers* 2) );
+        LOG_D(PHY,"[DLSIM][PTRS] Available bits are: %5u, removed PTRS bits are: %5u \n",available_bits, (ptrsSymbPerSlot * ptrsRePerSymb *rel15->nrOfLayers* 2) );
       }
 
       /*
@@ -1324,7 +1324,8 @@ int main(int argc, char **argv)
     printf("*****************************************\n");
     printf("\n");
     dump_pdsch_stats(stdout,gNB);
-    printf("SNR %f : n_errors (negative CRC) = %d/%d, Avg round %.2f, Channel BER %e, BLER %.2f, Eff Rate %.4f bits/slot, Eff Throughput %.2f, TBS %u bits/slot\n", SNR, n_errors, n_trials,roundStats[snrRun],berStats[snrRun],blerStats[snrRun],effRate,effRate/TBS*100,TBS);
+    printf("SNR %f : n_errors (negative CRC) = %d/%d, Avg round %.2f, Channel BER %e, BLER %.2f, Eff Rate %.4f bits/slot, Eff Throughput %.2f, TBS %u bits/slot\n",
+           SNR, n_errors, n_trials,roundStats[snrRun],berStats[snrRun],blerStats[snrRun],effRate,effRate/TBS*100,TBS);
     printf("\n");
 
     if (print_perf==1) {

openair1/SIMULATION/NR_PHY/ulschsim.c

@@ -407,15 +407,10 @@ int main(int argc, char **argv)
   }
 
   for (sf = 0; sf < 2; sf++) {
-    for (i = 0; i < 2; i++) {
-
-        UE->ulsch[sf][0][i] = new_nr_ue_ulsch(N_RB_UL, 8);
-
-        if (!UE->ulsch[sf][0][i]) {
-          printf("Can't get ue ulsch structures.\n");
-          exit(-1);
-        }
-
+    UE->ulsch[sf][0] = new_nr_ue_ulsch(N_RB_UL, 8);
+    if (!UE->ulsch[sf][0]) {
+      printf("Can't get ue ulsch structures.\n");
+      exit(-1);
     }
   }
 
@@ -431,11 +426,11 @@ int main(int argc, char **argv)
   uint8_t rvidx = 0;
   uint8_t UE_id = 0;
 
-  NR_gNB_ULSCH_t *ulsch_gNB = gNB->ulsch[UE_id][0];
+  NR_gNB_ULSCH_t *ulsch_gNB = gNB->ulsch[UE_id];
   NR_UL_gNB_HARQ_t *harq_process_gNB = ulsch_gNB->harq_processes[harq_pid];
   nfapi_nr_pusch_pdu_t *rel15_ul = &harq_process_gNB->ulsch_pdu;
 
-  NR_UE_ULSCH_t *ulsch_ue = UE->ulsch[0][0][0];
+  NR_UE_ULSCH_t *ulsch_ue = UE->ulsch[0][0];
 
   mod_order = nr_get_Qm_ul(Imcs, 0);
   code_rate = nr_get_code_rate_ul(Imcs, 0);
@@ -525,7 +520,7 @@ int main(int argc, char **argv)
             }
         */
 
-        if (ulsch_ue->g[i] == 0)
+        if (ulsch_ue->harq_processes[harq_pid]->f[i] == 0)
           modulated_input[i] = 1.0;        ///sqrt(2);  //QPSK
         else
           modulated_input[i] = -1.0;        ///sqrt(2);
@@ -615,8 +610,7 @@ int main(int argc, char **argv)
   }
 
   for (sf = 0; sf < 2; sf++)
-    for (i = 0; i < 2; i++)
-      free_nr_ue_ulsch(&UE->ulsch[sf][0][i], N_RB_UL);
+    free_nr_ue_ulsch(&UE->ulsch[sf][0], N_RB_UL);
   term_nr_ue_signal(UE, 1);
   free(UE);
 

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -804,7 +804,7 @@ int main(int argc, char **argv)
 
   unsigned char harq_pid = 0;
 
-  NR_gNB_ULSCH_t *ulsch_gNB = gNB->ulsch[UE_id][0];
+  NR_gNB_ULSCH_t *ulsch_gNB = gNB->ulsch[UE_id];
   //nfapi_nr_ul_config_ulsch_pdu *rel15_ul = &ulsch_gNB->harq_processes[harq_pid]->ulsch_pdu;
   nfapi_nr_ul_tti_request_t     *UL_tti_req  = malloc(sizeof(*UL_tti_req));
   NR_Sched_Rsp_t *Sched_INFO = malloc(sizeof(*Sched_INFO));
@@ -813,7 +813,7 @@ int main(int argc, char **argv)
 
   nfapi_nr_pusch_pdu_t  *pusch_pdu = &UL_tti_req->pdus_list[0].pusch_pdu;
 
-  NR_UE_ULSCH_t **ulsch_ue = UE->ulsch[0][0];
+  NR_UE_ULSCH_t *ulsch_ue = UE->ulsch[0][0];
 
   unsigned char *estimated_output_bit;
   unsigned char *test_input_bit;
@@ -1044,8 +1044,8 @@ int main(int argc, char **argv)
     memset((void*)roundStats,0,50*sizeof(roundStats[0]));
     while (round<max_rounds && crc_status) {
       round_trials[round][snrRun]++;
-      ulsch_ue[0]->harq_processes[harq_pid]->round = round;
-      gNB->ulsch[0][0]->harq_processes[harq_pid]->round = round;
+      ulsch_ue->harq_processes[harq_pid]->round = round;
+      gNB->ulsch[0]->harq_processes[harq_pid]->round = round;
       rv_index = nr_rv_round_map[round];
 
       UE_proc.thread_id = 0;
@@ -1186,7 +1186,7 @@ int main(int argc, char **argv)
 
       //nr_fill_ulsch(gNB,frame,slot,pusch_pdu); // Not needed as its its already filled as apart of "nr_schedule_response(Sched_INFO);"
 
-      for (int i=0;i<(TBS/8);i++) ulsch_ue[0]->harq_processes[harq_pid]->a[i]=i&0xff;
+      for (int i=0;i<(TBS/8);i++) ulsch_ue->harq_processes[harq_pid]->a[i]=i&0xff;
       if (input_fd == NULL) {
 
         // set FAPI parameters for UE, put them in the scheduled response and call
@@ -1361,8 +1361,8 @@ int main(int argc, char **argv)
 	}
         ////////////////////////////////////////////////////////////
 
-	if ((gNB->ulsch[0][0]->last_iteration_cnt >=
-	    gNB->ulsch[0][0]->max_ldpc_iterations+1) || ul_proc_error == 1) {
+	if ((gNB->ulsch[0]->last_iteration_cnt >=
+	    gNB->ulsch[0]->max_ldpc_iterations+1) || ul_proc_error == 1) {
 	  error_flag = 1; 
 	  n_errors[round][snrRun]++;
 	  crc_status = 1;
@@ -1387,8 +1387,8 @@ int main(int argc, char **argv)
 
 	for (i = 0; i < available_bits; i++) {
 	  
-	  if(((ulsch_ue[0]->g[i] == 0) && (gNB->pusch_vars[UE_id]->llr[i] <= 0)) ||
-	     ((ulsch_ue[0]->g[i] == 1) && (gNB->pusch_vars[UE_id]->llr[i] >= 0)))
+	  if(((ulsch_ue->harq_processes[harq_pid]->f[i] == 0) && (gNB->pusch_vars[UE_id]->llr[i] <= 0)) ||
+	     ((ulsch_ue->harq_processes[harq_pid]->f[i] == 1) && (gNB->pusch_vars[UE_id]->llr[i] >= 0)))
 	    {
 	      /*if(errors_scrambling == 0)
 		printf("\x1B[34m" "[frame %d][trial %d]\t1st bit in error in unscrambling = %d\n" "\x1B[0m", frame, trial, i);*/
@@ -1406,7 +1406,7 @@ int main(int argc, char **argv)
     for (i = 0; i < TBS; i++) {
       
       estimated_output_bit[i] = (ulsch_gNB->harq_processes[harq_pid]->b[i/8] & (1 << (i & 7))) >> (i & 7);
-      test_input_bit[i]       = (ulsch_ue[0]->harq_processes[harq_pid]->b[i/8] & (1 << (i & 7))) >> (i & 7);
+      test_input_bit[i]       = (ulsch_ue->harq_processes[harq_pid]->b[i/8] & (1 << (i & 7))) >> (i & 7);
       
       if (estimated_output_bit[i] != test_input_bit[i]) {
 	/*if(errors_decoding == 0)
@@ -1415,13 +1415,13 @@ int main(int argc, char **argv)
       }
     }
     if (n_trials == 1) {
-      for (int r=0;r<ulsch_ue[0]->harq_processes[harq_pid]->C;r++) 
-	for (int i=0;i<ulsch_ue[0]->harq_processes[harq_pid]->K>>3;i++) {
-	  if ((ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]) != 0) printf("************");
+      for (int r=0;r<ulsch_ue->harq_processes[harq_pid]->C;r++)
+	for (int i=0;i<ulsch_ue->harq_processes[harq_pid]->K>>3;i++) {
+	  if ((ulsch_ue->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]) != 0) printf("************");
 	    /*printf("r %d: in[%d] %x, out[%d] %x (%x)\n",r,
-	    i,ulsch_ue[0]->harq_processes[harq_pid]->c[r][i],
+	    i,ulsch_ue->harq_processes[harq_pid]->c[r][i],
 	    i,ulsch_gNB->harq_processes[harq_pid]->c[r][i],
-	    ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]);*/
+	    ulsch_ue->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]);*/
 	}
     }
     if (errors_decoding > 0 && error_flag == 0) {

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_bch.c

@@ -640,7 +640,7 @@ void schedule_nr_sib1(module_id_t module_idP, frame_t frameP, sub_frame_t slotP)
       nfapi_nr_pdu_t *tx_req = &gNB_mac->TX_req[CC_id].pdu_list[ntx_req];
 
       // Data to be transmitted
-      bzero(tx_req->TLVs[0].value.direct,MAX_NR_DLSCH_PAYLOAD_BYTES);
+      bzero(tx_req->TLVs[0].value.direct,MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*1056);
       memcpy(tx_req->TLVs[0].value.direct, sib1_payload, sib1_sdu_length);
 
       tx_req->PDU_length = TBS;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -55,8 +55,6 @@ extern RAN_CONTEXT_t RC;
 
 //#define ENABLE_MAC_PAYLOAD_DEBUG 1
 
-//uint8_t mac_pdu[MAX_NR_DLSCH_PAYLOAD_BYTES];
-
 /*Scheduling of DLSCH with associated DCI in common search space
  * current version has only a DCI for type 1 PDCCH for C_RNTI*/
 void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,