dynamic selection of codewords for DL init

openair1/PHY/INIT/nr_init.c

@@ -146,11 +146,12 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
     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++) {
+      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);
       }

openair1/PHY/INIT/nr_init_ue.c

@@ -296,11 +296,12 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
     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++) {
+      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);
       }
@@ -471,8 +472,10 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
 
 void init_nr_ue_transport(PHY_VARS_NR_UE *ue,
                           int abstraction_flag) {
+
+  int num_codeword = NR_MAX_NB_LAYERS > 4? 2:1;
   for (int i = 0; i < NUMBER_OF_CONNECTED_gNB_MAX; i++) {
-    for (int j=0; j<2; j++) {
+    for (int j=0; j<num_codeword; j++) {
       for (int k=0; k<RX_NB_TH_MAX; k++) {
         AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NR_MAX_DLSCH_HARQ_PROCESSES,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
         LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[k][i][j]);

openair1/PHY/NR_REFSIG/nr_gold.c

@@ -82,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;
   int pdsch_dmrs_init_length =  ((fp->N_RB_DL*12)>>5)+1;
-  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 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++) {
 
@@ -99,8 +100,8 @@ void nr_init_pdsch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
           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)*pdsch_dmrs_init_length);
+        if(nb_codewords>1)
+          memcpy(pdsch_dmrs[slot][symb][1],pdsch_dmrs[slot][symb][0],sizeof(uint32_t)*pdsch_dmrs_init_length);
     }
   }
 }

openair1/PHY/NR_REFSIG/nr_gold_ue.c

@@ -78,29 +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)%(1<<31);  //cinit
         LOG_D(PHY,"UE DMRS slot %d, symb %d, x2 %x, nscid %d\n",ns,l,x2,nscid);
 
-        for (n=0; n<pdsch_dmrs_init_length; 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;
         }

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -137,7 +137,9 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
     dlsch->txdataF[layer] = (int32_t *)malloc16((txdataf_size)*sizeof(int32_t));
   }
 
-  for (int q=0; q<NR_MAX_NB_CODEWORDS; q++)
+  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 *));

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -205,7 +205,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/defs_gNB.h

@@ -159,7 +159,7 @@ typedef struct {
   /// TX buffers for UE-spec transmission (antenna layers 1,...,4 after to precoding)
   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;
   /// dl channel estimates (estimated from ul channel estimates)

openair1/PHY/defs_nr_UE.h

@@ -817,7 +817,7 @@ typedef struct {
   NR_UE_PRACH     *prach_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_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];

openair1/PHY/defs_nr_common.h

@@ -79,7 +79,6 @@
 
 #define NR_MAX_NB_RBG 18
 #define NR_MAX_NB_LAYERS 4 // 8
-#define NR_MAX_NB_CODEWORDS 2
 #define NR_MAX_NB_HARQ_PROCESSES 16
 
 #define NR_MAX_PDSCH_TBS 3824

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -1847,13 +1847,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],
 			   dlsch_parallel);