2754 remove specific usage gold sequence cache, replaced by a generic usage...

2754 remove specific usage gold sequence cache, replaced by a generic usage cache. Make gold sequence common code for UE and gNB instead of source duplication

CMakeLists.txt

@@ -1045,6 +1045,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_csi_rs.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_scrambling.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/scrambling_luts.c
+  ${OPENAIR1_DIR}/PHY/NR_REFSIG/refsig.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/srs_modulation_nr.c
   )
 

openair1/PHY/INIT/nr_init.c

@@ -140,109 +140,16 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
   gNB->max_nb_pdsch = MAX_MOBILES_PER_GNB;
   init_delay_table(fp->ofdm_symbol_size, MAX_DELAY_COMP, NR_MAX_OFDM_SYMBOL_SIZE, fp->delay_table);
 
-  // PBCH DMRS gold sequences generation
-  nr_init_pbch_dmrs(gNB);
-  //PDCCH DMRS init
-  gNB->nr_gold_pdcch_dmrs = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t **));
-  uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
-  AssertFatal(pdcch_dmrs!=NULL, "NR init: pdcch_dmrs malloc failed\n");
-
   gNB->bad_pucch = 0;
   if (gNB->TX_AMP == 0)
     gNB->TX_AMP = AMP;
   // 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(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);
-    }
-  }
-
   nr_generate_modulation_table();
-  gNB->pdcch_gold_init = cfg->cell_config.phy_cell_id.value;
-  nr_init_pdcch_dmrs(gNB, cfg->cell_config.phy_cell_id.value);
   nr_init_pbch_interleaver(gNB->nr_pbch_interleaver);
 
-  //PDSCH DMRS init
-  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*12(k)*2(QPSK)/32) // 3 RE *2(QPSK)
-  const int pdsch_dmrs_init_length =  ((fp->N_RB_DL*24)>>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);
-
-    for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-      pdsch_dmrs[slot][symb] = (uint32_t **)malloc16(NR_NB_NSCID*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_NB_NSCID; q++) {
-        pdsch_dmrs[slot][symb][q] = malloc16(pdsch_dmrs_init_length * sizeof(uint32_t));
-        AssertFatal(pdsch_dmrs[slot][symb][q]!=NULL, "NR init: pdsch_dmrs for slot %d symbol %d nscid %d - malloc failed\n", slot, symb, q);
-        memset(pdsch_dmrs[slot][symb][q], 0, sizeof(uint32_t) * pdsch_dmrs_init_length);
-      }
-    }
-  }
-
-
-  for (int nscid = 0; nscid < NR_NB_NSCID; nscid++) {
-    gNB->pdsch_gold_init[nscid] = cfg->cell_config.phy_cell_id.value;
-    nr_init_pdsch_dmrs(gNB, nscid, cfg->cell_config.phy_cell_id.value);
-  }
-
-  //PUSCH DMRS init
-  gNB->nr_gold_pusch_dmrs = (uint32_t ****)malloc16(NR_NB_NSCID*sizeof(uint32_t ***));
-
-  uint32_t ****pusch_dmrs = gNB->nr_gold_pusch_dmrs;
-
-  int pusch_dmrs_init_length =  ((fp->N_RB_UL*12)>>5)+1;
-  for(int nscid=0; nscid<NR_NB_NSCID; 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);
-
-    for (int slot=0; slot<fp->slots_per_frame; slot++) {
-      pusch_dmrs[nscid][slot] = (uint32_t **)malloc16(fp->symbols_per_slot*sizeof(uint32_t *));
-      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(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);
-      }
-    }
-  }
-
-  for (int nscid=0; nscid<NR_NB_NSCID; nscid++) {
-    gNB->pusch_gold_init[nscid] = cfg->cell_config.phy_cell_id.value;
-    nr_gold_pusch(gNB, nscid, gNB->pusch_gold_init[nscid]);
-  }
-
   // CSI RS init
   // ceil((NB_RB*8(max allocation per RB)*2(QPSK))/32)
-  int csi_dmrs_init_length =  ((fp->N_RB_DL<<4)>>5)+1;
   gNB->nr_csi_info = (nr_csi_info_t *)malloc16_clear(sizeof(nr_csi_info_t));
-  gNB->nr_csi_info->nr_gold_csi_rs = (uint32_t ***)malloc16(fp->slots_per_frame * sizeof(uint32_t **));
-  AssertFatal(gNB->nr_csi_info->nr_gold_csi_rs != NULL, "NR init: csi reference signal malloc failed\n");
-  for (int slot=0; slot<fp->slots_per_frame; slot++) {
-    gNB->nr_csi_info->nr_gold_csi_rs[slot] = (uint32_t **)malloc16(fp->symbols_per_slot * sizeof(uint32_t *));
-    AssertFatal(gNB->nr_csi_info->nr_gold_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++) {
-      gNB->nr_csi_info->nr_gold_csi_rs[slot][symb] = (uint32_t *)malloc16(csi_dmrs_init_length * sizeof(uint32_t));
-      AssertFatal(gNB->nr_csi_info->nr_gold_csi_rs[slot][symb] != NULL, "NR init: csi reference signal for slot %d symbol %d - malloc failed\n", slot, symb);
-    }
-  }
-
-  gNB->nr_csi_info->csi_gold_init = cfg->cell_config.phy_cell_id.value;
-  nr_init_csi_rs(&gNB->frame_parms, gNB->nr_csi_info->nr_gold_csi_rs, cfg->cell_config.phy_cell_id.value);
-
-  //PRS init
-  nr_init_prs(gNB);
 
   generate_ul_reference_signal_sequences(SHRT_MAX);
 
@@ -327,7 +234,6 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 
 void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
 {
-  NR_DL_FRAME_PARMS* const fp = &gNB->frame_parms;
   const int Ptx = gNB->gNB_config.carrier_config.num_tx_ant.value;
   const int Prx = gNB->gNB_config.carrier_config.num_rx_ant.value;
   const int max_ul_mimo_layers = 4; // taken from phy_init_nr_gNB()
@@ -339,43 +245,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   free_and_zero(meas->n0_subband_power);
   free_and_zero(meas->n0_subband_power_dB);
 
-  uint32_t ***pdcch_dmrs = gNB->nr_gold_pdcch_dmrs;
-  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
-    for (int symb = 0; symb < fp->symbols_per_slot; symb++)
-      free_and_zero(pdcch_dmrs[slot][symb]);
-    free_and_zero(pdcch_dmrs[slot]);
-  }
-  free_and_zero(pdcch_dmrs);
-
-  uint32_t ****pdsch_dmrs = gNB->nr_gold_pdsch_dmrs;
-  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_NB_NSCID; q++)
-        free_and_zero(pdsch_dmrs[slot][symb][q]);
-      free_and_zero(pdsch_dmrs[slot][symb]);
-    }
-    free_and_zero(pdsch_dmrs[slot]);
-  }
-  free_and_zero(gNB->nr_gold_pdsch_dmrs);
-
-  uint32_t ****pusch_dmrs = gNB->nr_gold_pusch_dmrs;
-  for(int nscid = 0; nscid < 2; nscid++) {
-    for (int slot = 0; slot < fp->slots_per_frame; slot++) {
-      for (int symb = 0; symb < fp->symbols_per_slot; symb++)
-        free_and_zero(pusch_dmrs[nscid][slot][symb]);
-      free_and_zero(pusch_dmrs[nscid][slot]);
-    }
-    free_and_zero(pusch_dmrs[nscid]);
-  }
-  free_and_zero(pusch_dmrs);
-
-  uint32_t ***nr_gold_csi_rs = gNB->nr_csi_info->nr_gold_csi_rs;
-  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
-    for (int symb = 0; symb < fp->symbols_per_slot; symb++)
-      free_and_zero(nr_gold_csi_rs[slot][symb]);
-    free_and_zero(nr_gold_csi_rs[slot]);
-  }
-  free_and_zero(nr_gold_csi_rs);
   free_and_zero(gNB->nr_csi_info);
 
   for (int id = 0; id < gNB->max_nb_srs; id++) {
@@ -398,17 +267,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
     free_and_zero(common_vars->beam_id[i]);
   }
 
-  for (int rsc=0; rsc < gNB->prs_vars.NumPRSResources; rsc++) {
-    for (int slot=0; slot<fp->slots_per_frame; slot++) {
-      for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-        free_and_zero(gNB->nr_gold_prs[rsc][slot][symb]);
-      }
-      free_and_zero(gNB->nr_gold_prs[rsc][slot]);
-    }
-    free_and_zero(gNB->nr_gold_prs[rsc]);
-  }
-  free_and_zero(gNB->nr_gold_prs);
-
   /* Do NOT free per-antenna txdataF/rxdataF: the gNB gets a pointer to the
    * RU's txdataF/rxdataF, and the RU will free that */
   free_and_zero(common_vars->txdataF);

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -102,16 +102,17 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 
   //------------------generate DMRS------------------//
 
-  if(pusch_pdu->ul_dmrs_scrambling_id != gNB->pusch_gold_init[pusch_pdu->scid])  {
-    gNB->pusch_gold_init[pusch_pdu->scid] = pusch_pdu->ul_dmrs_scrambling_id;
-    nr_gold_pusch(gNB, pusch_pdu->scid, pusch_pdu->ul_dmrs_scrambling_id);
-  }
-
   if (pusch_pdu->transform_precoding == transformPrecoder_disabled) {
     // Note: pilot returned by the following function is already the complex conjugate of the transmitted DMRS
+    NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
     nr_pusch_dmrs_rx(gNB,
                      Ns,
-                     gNB->nr_gold_pusch_dmrs[pusch_pdu->scid][Ns][symbol],
+                     nr_gold_pusch(fp->N_RB_UL,
+                                   fp->symbols_per_slot,
+                                   gNB->gNB_config.cell_config.phy_cell_id.value,
+                                   pusch_pdu->scid,
+                                   Ns,
+                                   symbol),
                      pilot,
                      (1000 + p),
                      0,
@@ -559,7 +560,12 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                              symbol,
                              frame_parms->ofdm_symbol_size,
                              (int16_t *)&pusch_vars->rxdataF_comp[aarx][(symbol * nb_re_pusch)],
-                             gNB->nr_gold_pusch_dmrs[rel15_ul->scid][nr_tti_rx][symbol],
+                             nr_gold_pusch(frame_parms->N_RB_UL,
+                                           frame_parms->symbols_per_slot,
+                                           gNB->gNB_config.cell_config.phy_cell_id.value,
+                                           rel15_ul->scid,
+                                           nr_tti_rx,
+                                           symbol),
                              (int16_t *)&phase_per_symbol[symbol],
                              ptrs_re_symbol);
     }

openair1/PHY/NR_REFSIG/nr_gold.c

@@ -20,150 +20,4 @@
  */
 
 #include "nr_refsig.h"
-
-void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB)
-{
-  unsigned int x1 = 0, x2 = 0;
-  uint16_t Nid, i_ssb, i_ssb2;
-  unsigned char Lmax, l, n_hf, N_hf;
-  nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
-  uint8_t reset;
-
-  Nid = cfg->cell_config.phy_cell_id.value;
-
-  Lmax = fp->Lmax;
-  N_hf = (Lmax == 4)? 2:1;
-
-  for (n_hf = 0; n_hf < N_hf; n_hf++) {
-    for (l = 0; l < Lmax ; l++) {
-      i_ssb = l & (Lmax-1);
-      i_ssb2 = i_ssb + (n_hf<<2);
-
-      reset = 1;
-      x2 = (1<<11) * (i_ssb2 + 1) * ((Nid>>2) + 1) + (1<<6) * (i_ssb2 + 1) + (Nid&3);
-
-      for (uint8_t n=0; n<NR_PBCH_DMRS_LENGTH_DWORD; n++) {
-        gNB->nr_gold_pbch_dmrs[n_hf][l][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-
-    }
-  }
-
-}
-
-void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
-{
-  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 (int slot = 0; slot < fp->slots_per_frame; slot++) {
-    for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
-      uint8_t reset = 1;
-      uint32_t x1 = 0;
-      uint64_t temp_x2 = ((1UL << 17) * (fp->symbols_per_slot * slot + symb + 1) * ((Nid << 1) + 1) + (Nid << 1));
-      uint32_t x2 = temp_x2 % (1U << 31);
-      LOG_D(PHY,"PDCCH DMRS slot %d, symb %d, Nid %d, x2 %x\n", slot, symb, Nid, x2);
-      for (uint32_t n = 0; n < pdcch_dmrs_init_length; n++) {
-        pdcch_dmrs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-    }  
-  }
-}
-
-
-void nr_init_pdsch_dmrs(PHY_VARS_gNB* gNB, uint8_t nscid, uint32_t Nid)
-{
-  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;
-  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
-    for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
-      uint8_t reset = 1;
-      uint32_t x1 = 0;
-      uint64_t temp_x2 = ((1UL << 17) * (fp->symbols_per_slot * slot + symb + 1) * ((Nid << 1) + 1) + ((Nid << 1) + nscid));
-      uint32_t x2 = temp_x2 % (1U << 31);
-      LOG_D(PHY,"PDSCH DMRS slot %d, symb %d, Nid %d, nscid %d, x2 %x\n",slot, symb, Nid, nscid, x2);
-      for (uint32_t n = 0; n < pdsch_dmrs_init_length; n++) {
-        pdsch_dmrs[slot][symb][nscid][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-    }
-  }
-}
-
-
-void nr_gold_pusch(PHY_VARS_gNB* gNB, int nscid, uint32_t nid)
-{
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
-  int pusch_dmrs_init_length = ((fp->N_RB_UL * 12) >> 5) + 1;
-  for (int ns = 0; ns < fp->slots_per_frame; ns++) {
-    for (int l = 0; l < fp->symbols_per_slot; l++) {
-      int reset = 1;
-      uint32_t x1 = 0;
-      uint64_t temp_x2 = ((1UL << 17) * (fp->symbols_per_slot * ns + l + 1) * ((nid << 1) + 1) + ((nid << 1) + nscid));
-      uint32_t x2 = temp_x2 % (1U << 31);
-      LOG_D(PHY,"DMRS slot %d, symb %d, nscid %d, nid %d, x2 %x\n", ns, l, nscid, nid, x2);
-      for (int 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;
-      }
-    }
-  }
-}
-
-
-void nr_init_prs(PHY_VARS_gNB* gNB)
-{
-  unsigned int x1 = 0, x2 = 0;
-  uint16_t Nid;
-
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
-  gNB->nr_gold_prs = (uint32_t ****)malloc16(gNB->prs_vars.NumPRSResources*sizeof(uint32_t ***));
-  uint32_t ****prs = gNB->nr_gold_prs;
-  AssertFatal(prs!=NULL, "NR init: positioning reference signal malloc failed\n");
-  for (int rsc=0; rsc < gNB->prs_vars.NumPRSResources; rsc++) {
-    prs[rsc] = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t **));
-    AssertFatal(prs[rsc]!=NULL, "NR init: positioning reference signal for rsc %d - malloc failed\n", rsc);
-
-    for (int slot=0; slot<fp->slots_per_frame; slot++) {
-      prs[rsc][slot] = (uint32_t **)malloc16(fp->symbols_per_slot*sizeof(uint32_t *));
-      AssertFatal(prs[rsc][slot]!=NULL, "NR init: positioning reference signal for slot %d - malloc failed\n", slot);
-
-      for (int symb=0; symb<fp->symbols_per_slot; symb++) {
-        prs[rsc][slot][symb] = (uint32_t *)malloc16(NR_MAX_PRS_INIT_LENGTH_DWORD*sizeof(uint32_t));
-        AssertFatal(prs[rsc][slot][symb]!=NULL, "NR init: positioning reference signal for rsc %d slot %d symbol %d - malloc failed\n", rsc, slot, symb);
-      }
-    }
-  }
-
-  uint8_t reset;
-  uint8_t slotNum, symNum, rsc_id;
-
-  for (rsc_id = 0; rsc_id < gNB->prs_vars.NumPRSResources; rsc_id++) {
-    Nid = gNB->prs_vars.prs_cfg[rsc_id].NPRSID; // seed value
-    LOG_I(PHY, "Initiaized NR-PRS sequence with PRS_ID %3d for resource %d\n", Nid, rsc_id);
-    for (slotNum = 0; slotNum < fp->slots_per_frame; slotNum++) {
-      for (symNum = 0; symNum < fp->symbols_per_slot ; symNum++) {
-        reset = 1;
-        // initial x2 for prs as ts138.211
-        uint32_t c_init1, c_init2, c_init3;
-        uint32_t pow22=1<<22;
-        uint32_t pow10=1<<10;
-        c_init1 = pow22*ceil(Nid/1024);
-        c_init2 = pow10*(slotNum+symNum+1)*(2*(Nid%1024)+1);
-        c_init3 = Nid%1024;
-        x2 = c_init1 + c_init2 + c_init3;
-
-        for (uint8_t n=0; n<NR_MAX_PRS_INIT_LENGTH_DWORD; n++) {
-          gNB->nr_gold_prs[rsc_id][slotNum][symNum][n] = lte_gold_generic(&x1, &x2, reset);      
-          reset = 0;
-          //printf("%d \n",gNB->nr_gold_prs[slotNum][symNum][n]); 
-        }
-      }
-    }
-  }
-}
+#include "nr_refsig_common.h"

openair1/PHY/NR_REFSIG/nr_gold_ue.c

@@ -20,132 +20,8 @@
  */
 
 #include "refsig_defs_ue.h"
-
-void nr_gold_pbch(uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD], int Nid, int Lmax)
-{
-  unsigned int n = 0, x1 = 0, x2 = 0;
-  unsigned int i_ssb, i_ssb2;
-  unsigned char l, n_hf, N_hf;
-  uint8_t reset;
-
-  N_hf = (Lmax == 4)? 2:1;
-
-  for (n_hf = 0; n_hf < N_hf; n_hf++) {
-
-    for (l = 0; l < Lmax ; l++) {
-      i_ssb = l & (Lmax-1);
-      i_ssb2 = i_ssb + (n_hf<<2);
-
-      reset = 1;
-      x2 = (1<<11) * (i_ssb2 + 1) * ((Nid>>2) + 1) + (1<<6) * (i_ssb2 + 1) + (Nid&3);
-
-      for (n=0; n<NR_PBCH_DMRS_LENGTH_DWORD; n++) {
-        nr_gold_pbch[n_hf][l][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-
-    }
-  }
-
-}
-
-void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
-                   unsigned short nid)
-{
-  int pdcch_dmrs_init_length = (((ue->frame_parms.N_RB_DL << 1) * 3) >> 5) + 1;
-  for (int ns = 0; ns < ue->frame_parms.slots_per_frame; ns++) {
-    for (int l = 0; l < ue->frame_parms.symbols_per_slot; l++) {
-      uint8_t reset = 1;
-      uint64_t x2tmp0 = ((ue->frame_parms.symbols_per_slot * ns + l + 1) * ((nid << 1) + 1));
-      x2tmp0 <<= 17;
-      x2tmp0 += (nid << 1);
-      uint32_t x1 = 0;
-      uint32_t x2 = x2tmp0 % (1U << 31);  //cinit
-      LOG_D(PHY,"PDCCH DMRS slot %d, symb %d, Nid %d, x2 %x\n", ns, l, nid, x2);
-      for (int n = 0; n < pdcch_dmrs_init_length; n++) {
-        ue->nr_gold_pdcch[0][ns][l][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }    
-    }
-  }
-}
-
-void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   int nscid,
-                   uint32_t nid)
-{
-  int pdsch_dmrs_init_length = ((ue->frame_parms.N_RB_DL * 12) >> 5) + 1;
-  for (int ns=0; ns<ue->frame_parms.slots_per_frame; ns++) {
-    for (int l=0; l<ue->frame_parms.symbols_per_slot; l++) {
-      uint8_t reset = 1;
-      uint64_t x2tmp0 = ((ue->frame_parms.symbols_per_slot * ns + l + 1) * ((nid << 1) + 1)) << 17;
-      uint32_t x1 = 0;
-      uint32_t x2 = (x2tmp0 + (nid << 1) + nscid) % (1U << 31);  //cinit
-      LOG_D(PHY,"UE DMRS slot %d, symb %d, nscid %d, x2 %x\n", ns, l, nscid, x2);
-      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;
-      }
-    }
-  }
-}
-
-void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue, uint16_t N_n_scid, uint8_t n_scid)
-{
-  NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
-  uint32_t ****pusch_dmrs = ue->nr_gold_pusch_dmrs;
-  int pusch_dmrs_init_length = ((fp->N_RB_UL * 12) >> 5) + 1;
-  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
-    for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
-      int reset = 1;
-      uint32_t x1 = 0;
-      uint64_t t_x2 = ((1UL << 17) * (fp->symbols_per_slot*slot + symb + 1) * ((N_n_scid << 1) + 1) + ((N_n_scid << 1) + n_scid));
-      uint32_t x2 = t_x2 % (1U << 31);
-      LOG_D(PHY,"DMRS slot %d, symb %d, N_n_scid %d, n_scid %d, x2 %x\n", slot, symb, N_n_scid, n_scid, x2);
-      for (int n = 0; n < pusch_dmrs_init_length; n++) {
-        pusch_dmrs[slot][symb][n_scid][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-    }
-  }
-}
-
-void init_nr_gold_prs(PHY_VARS_NR_UE* ue)
-{
-  unsigned int x1 = 0, x2 = 0;
-  uint16_t Nid;
-
-  NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
-  uint8_t reset;
-  uint8_t slotNum, symNum, gnb, rsc;
-  
-  for(gnb = 0; gnb < ue->prs_active_gNBs; gnb++) {
-    for(rsc = 0; rsc < ue->prs_vars[gnb]->NumPRSResources; rsc++) {
-      Nid = ue->prs_vars[gnb]->prs_resource[rsc].prs_cfg.NPRSID; // seed value
-      LOG_I(PHY,"Initialised NR-PRS sequence with PRS_ID %3d for resource %d\n",Nid, rsc);
-      for (slotNum = 0; slotNum < fp->slots_per_frame; slotNum++) {
-        for (symNum = 0; symNum < fp->symbols_per_slot ; symNum++) {
-          reset = 1;
-          // initial x2 for prs as ts138.211
-          uint32_t c_init1, c_init2, c_init3;
-          uint32_t pow22=1<<22;
-          uint32_t pow10=1<<10;
-          c_init1 = pow22*ceil(Nid/1024);
-          c_init2 = pow10*(slotNum+symNum+1)*(2*(Nid%1024)+1);
-          c_init3 = Nid%1024;
-          x2 = c_init1 + c_init2 + c_init3;
-
-          for (uint8_t n=0; n<NR_MAX_PRS_INIT_LENGTH_DWORD; n++) {
-            ue->nr_gold_prs[gnb][rsc][slotNum][symNum][n] = lte_gold_generic(&x1, &x2, reset);      
-            reset = 0;
-            //printf("%d \n",gNB->nr_gold_prs[slotNum][symNum][n]); 
-	    
-          }
-        }
-      }
-    } // for rsc
-  } // for gnb
-}
+#include "nr_refsig.h"
+#include "nr_refsig_common.h"
 
 void sl_init_psbch_dmrs_gold_sequences(PHY_VARS_NR_UE *UE)
 {

openair1/PHY/NR_REFSIG/nr_refsig.h

@@ -25,30 +25,12 @@
 #define __NR_REFSIG__H__
 
 #include "PHY/defs_gNB.h"
-#include "PHY/LTE_REFSIG/lte_refsig.h"
-#include "PHY/sse_intrin.h"
-
-/*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PBCH DMRS.
-@param PHY_VARS_gNB* gNB structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
- */
-void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB);
-
-/*
-This function generates NR Gold Sequence(ts 138.211) for the PRS.
-@param PHY_VARS_gNB* gNB structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
-*/
-void nr_init_prs(PHY_VARS_gNB* gNB);
+#include "openair1/PHY/NR_REFSIG/nr_refsig_common.h"
 
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PDCCH DMRS.
 @param PHY_VARS_gNB* gNB structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
 @param Nid is used for the initialization of x2, Physical cell Id by default or upper layer configured pdcch_scrambling_ID
  */
-void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid);
-void nr_init_pdsch_dmrs(PHY_VARS_gNB* gNB, uint8_t nscid, uint32_t Nid);
-void nr_init_csi_rs(const NR_DL_FRAME_PARMS *fp, uint32_t ***csi_rs, uint32_t Nid);
-
-void nr_gold_pusch(PHY_VARS_gNB* gNB, int nscid, uint32_t nid);
-
 int nr_pusch_dmrs_delta(uint8_t dmrs_config_type, unsigned short p);
 
 int nr_pusch_dmrs_rx(PHY_VARS_gNB *gNB,

openair1/PHY/NR_REFSIG/nr_refsig_common.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* Definitions for LTE Reference signals */
+/* Author R. Knopp / EURECOM / OpenAirInterface.org */
+#ifndef __NR_REFSIG_COMMON_H__
+#define __NR_REFSIG_COMMON_H__
+
+#include "openair1/PHY/LTE_TRANSPORT/transport_proto.h"
+uint32_t* gold_cache(uint32_t key, int length);
+uint32_t *nr_gold_pbch(int Lmax, int Nid, int n_hf, int ssb);
+uint32_t *nr_gold_pdcch(int N_RB_DL, int symbols_per_slot, unsigned short n_idDMRS, int ns, int l);
+uint32_t *nr_gold_pdsch(int N_RB_DL, int symbols_per_slot, int nid, int nscid, int slot, int symbol);
+uint32_t *nr_gold_pusch(int N_RB_UL, int symbols_per_slot, int Nid, int nscid, int ns, int l);
+uint32_t *nr_gold_csi_rs(const NR_DL_FRAME_PARMS *fp, int slot, int symb, uint32_t Nid);
+uint32_t *nr_gold_prs(int nid, int slot, int symbol);
+
+#endif

openair1/PHY/NR_REFSIG/refsig.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "nr_refsig.h"
+
+uint32_t* gold_cache(uint32_t key, int length)
+{
+  typedef struct {
+    int key;
+    int length;
+    int usage;
+    uint32_t* sequence;
+  } gold_cache_t;
+#define GOLD_CACHE_SZ PAGE_SIZE / sizeof(gold_cache_t)
+  static __thread gold_cache_t table[GOLD_CACHE_SZ] = {0};
+  static __thread int calls = 0;
+  calls++;
+  // check if already cached
+  for (int i = 0; i < GOLD_CACHE_SZ; i++)
+    if (table[i].length && table[i].key == key) {
+      if (table[i].length >= length) {
+        table[i].usage++;
+        return table[i].sequence;
+      } else {
+        // cached, but too short, let's recompute it
+        free(table[i].sequence);
+        table[i].length = 0;
+      }
+    }
+
+  // cleanup unused entries since last adding
+  if (calls > GOLD_CACHE_SZ)
+    for (int i = 0; i < GOLD_CACHE_SZ; i++) {
+      if (table[i].length && !table[i].usage) {
+        free(table[i].sequence);
+        table[i].length = 0;
+      }
+      table[i].usage = 0;
+    }
+  calls = 0;
+
+  // We will add a new entry
+  for (int i = 0; i < GOLD_CACHE_SZ; i++)
+    if (table[i].length == 0) {
+      table[i].key = key;
+      table[i].length = length;
+      table[i].usage = 1;
+      table[i].sequence = malloc(length * sizeof(*table[i].sequence));
+      unsigned int x1 = 0, x2 = key;
+      table[i].sequence[0] = lte_gold_generic(&x1, &x2, 1);
+      for (int n = 1; n < length; n++)
+        table[i].sequence[n] = lte_gold_generic(&x1, &x2, 0);
+      LOG_D(PHY, "created a gold sequence, start %d; len %d\n", key, length);
+      return table[i].sequence;
+    }
+  AssertFatal(PHY, "gold sequence table full\n");
+}
+
+uint32_t* nr_gold_pbch(int Lmax, int Nid, int n_hf, int l)
+{
+  int i_ssb = l & (Lmax - 1);
+  int i_ssb2 = i_ssb + (n_hf << 2);
+  uint32_t x2 = (1 << 11) * (i_ssb2 + 1) * ((Nid >> 2) + 1) + (1 << 6) * (i_ssb2 + 1) + (Nid & 3);
+  return gold_cache(x2, NR_PBCH_DMRS_LENGTH_DWORD);
+}
+
+uint32_t* nr_gold_pdcch(int N_RB_DL, int symbols_per_slot, unsigned short nid, int ns, int l)
+{
+  int pdcch_dmrs_init_length = (((N_RB_DL << 1) * 3) >> 5) + 1;
+  uint64_t x2tmp0 = ((symbols_per_slot * ns + l + 1) * ((nid << 1) + 1));
+  x2tmp0 <<= 17;
+  x2tmp0 += (nid << 1);
+  uint32_t x2 = x2tmp0 % (1U << 31); // cinit
+  LOG_D(PHY, "PDCCH DMRS slot %d, symb %d, Nid %d, x2 %x\n", ns, l, nid, x2);
+  return gold_cache(x2, pdcch_dmrs_init_length);
+}
+
+uint32_t* nr_gold_pdsch(int N_RB_DL, int symbols_per_slot, int nid, int nscid, int slot, int symbol)
+{
+  int pdsch_dmrs_init_length = ((N_RB_DL * 24) >> 5) + 1;
+  uint64_t x2tmp0 = ((symbols_per_slot * slot + symbol + 1) * ((nid << 1) + 1)) << 17;
+  uint32_t x2 = (x2tmp0 + (nid << 1) + nscid) % (1U << 31); // cinit
+  LOG_D(PHY, "UE DMRS slot %d, symb %d, nscid %d, x2 %x\n", slot, symbol, nscid, x2);
+  return gold_cache(x2, pdsch_dmrs_init_length);
+}
+
+uint32_t* nr_gold_pusch(int N_RB_UL, int symbols_per_slot, int Nid, int nscid, int ns, int l)
+{
+  int pusch_dmrs_init_length = ((N_RB_UL * 12) >> 5) + 1;
+  uint64_t temp_x2 = ((1UL << 17) * (symbols_per_slot * ns + l + 1) * ((Nid << 1) + 1) + ((Nid << 1) + nscid));
+  uint32_t x2 = temp_x2 % (1U << 31);
+  LOG_D(PHY, "DMRS slot %d, symb %d, nscid %d, nid %d, x2 %x\n", ns, l, nscid, Nid, x2);
+  return gold_cache(x2, pusch_dmrs_init_length);
+}
+
+uint32_t* nr_gold_csi_rs(const NR_DL_FRAME_PARMS* fp, int slot, int symb, uint32_t Nid)
+{
+  int csi_dmrs_init_length =  ((fp->N_RB_DL<<4)>>5)+1;
+  uint32_t x2 = ((1<<10) * (fp->symbols_per_slot*slot+symb+1) * ((Nid<<1)+1) + (Nid));
+  return gold_cache(x2, csi_dmrs_init_length);
+}
+
+uint32_t* nr_gold_prs(int Nid, int slotNum, int symNum)
+{
+  LOG_I(PHY, "Initialised NR-PRS sequence for PCI %d\n", Nid);
+  // initial x2 for prs as ts138.211
+  uint32_t pow22 = 1 << 22;
+  uint32_t pow10 = 1 << 10;
+  uint32_t c_init1 = pow22 * ceil(Nid / 1024);
+  uint32_t c_init2 = pow10 * (slotNum + symNum + 1) * (2 * (Nid % 1024) + 1);
+  uint32_t c_init3 = Nid % 1024;
+  uint32_t x2 = c_init1 + c_init2 + c_init3;
+  return gold_cache(x2, NR_MAX_PRS_INIT_LENGTH_DWORD);
+}

openair1/PHY/NR_REFSIG/refsig_defs_ue.h

@@ -25,7 +25,7 @@
 #define __NR_REFSIG_DEFS__H__
 
 #include "PHY/defs_nr_UE.h"
-#include "PHY/LTE_REFSIG/lte_refsig.h"
+#include "nr_refsig_common.h"
 
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PBCH DMRS.
 @param PHY_VARS_NR_UE* ue structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
@@ -51,21 +51,6 @@ int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
                      unsigned short nb_pdsch_rb,
                      uint8_t config_type);
 
-void nr_gold_pbch(uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD], int Nid, int Lmax);
-
-void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
-                   unsigned short n_idDMRS);
-
-void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   int nscid,
-                   uint32_t nid);
-
-void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue,
-                        uint16_t N_n_scid,
-                        uint8_t n_scid);
-
-void nr_init_csi_rs(const NR_DL_FRAME_PARMS *fp, uint32_t ***csi_rs, uint32_t Nid);
-void init_nr_gold_prs(PHY_VARS_NR_UE* ue);
 void sl_generate_pss(SL_NR_UE_INIT_PARAMS_t *sl_init_params, uint8_t n_sl_id2, uint16_t scaling);
 void sl_generate_pss_ifft_samples(sl_nr_ue_phy_params_t *sl_ue_params, SL_NR_UE_INIT_PARAMS_t *sl_init_params);
 void sl_generate_sss(SL_NR_UE_INIT_PARAMS_t *sl_init_params, uint16_t slss_id, uint16_t scaling);

openair1/PHY/NR_TRANSPORT/nr_csi_rs.c

@@ -26,23 +26,6 @@
 
 //#define NR_CSIRS_DEBUG
 
-
-void nr_init_csi_rs(const NR_DL_FRAME_PARMS *fp, uint32_t ***csi_rs, uint32_t Nid) {
-  uint32_t x1 = 0, x2 = 0;
-  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++) {
-      reset = 1;
-      x2 = ((1<<10) * (fp->symbols_per_slot*slot+symb+1) * ((Nid<<1)+1) + (Nid));
-      for (uint32_t n=0; n<csi_dmrs_init_length; n++) {
-        csi_rs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
-        reset = 0;
-      }
-    }
-  }
-}
-
 void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
                         int32_t **dataF,
                         const int16_t amp,
@@ -75,8 +58,7 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
   LOG_I(NR_PHY, "csi_params->power_control_offset_ss = %i\n", csi_params->power_control_offset_ss);
 #endif
 
-  int dataF_offset = slot*frame_parms->samples_per_slot_wCP;
-  uint32_t **nr_gold_csi_rs = nr_csi_info->nr_gold_csi_rs[slot];
+  int dataF_offset = slot * frame_parms->samples_per_slot_wCP;
   //*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)));
@@ -93,12 +75,6 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
 
   AssertFatal(b!=0, "Invalid CSI frequency domain mapping: no bit selected in bitmap\n");
 
-  // if the scrambling id is not the one previously used to initialize we need to re-initialize the rs
-  if (csi_params->scramb_id != nr_csi_info->csi_gold_init) {
-    nr_csi_info->csi_gold_init = csi_params->scramb_id;
-    nr_init_csi_rs(frame_parms, nr_csi_info->nr_gold_csi_rs, csi_params->scramb_id);
-  }
-
   switch (csi_params->row) {
   // implementation of table 7.4.1.5.3-1 of 38.211
   // lprime and kprime are the max value of l' and k'
@@ -580,14 +556,26 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
 
     for (lp=0; lp<=lprime; lp++){
       symb = csi_params->symb_l0;
-      nr_modulation(nr_gold_csi_rs[symb+lp], csi_length, DMRS_MOD_ORDER, mod_csi[symb+lp]);
+      nr_modulation(nr_gold_csi_rs(frame_parms, slot, symb + lp, csi_params->scramb_id),
+                    csi_length,
+                    DMRS_MOD_ORDER,
+                    mod_csi[symb + lp]);
       if ((csi_params->row == 5) || (csi_params->row == 7) || (csi_params->row == 11) || (csi_params->row == 13) || (csi_params->row == 16))
-        nr_modulation(nr_gold_csi_rs[symb+1], csi_length, DMRS_MOD_ORDER, mod_csi[symb+1]);
+        nr_modulation(nr_gold_csi_rs(frame_parms, slot, symb + 1, csi_params->scramb_id),
+                      csi_length,
+                      DMRS_MOD_ORDER,
+                      mod_csi[symb + 1]);
       if ((csi_params->row == 14) || (csi_params->row == 13) || (csi_params->row == 16) || (csi_params->row == 17)) {
         symb = csi_params->symb_l1;
-        nr_modulation(nr_gold_csi_rs[symb+lp], csi_length, DMRS_MOD_ORDER, mod_csi[symb+lp]);
+        nr_modulation(nr_gold_csi_rs(frame_parms, slot, symb + lp, csi_params->scramb_id),
+                      csi_length,
+                      DMRS_MOD_ORDER,
+                      mod_csi[symb + lp]);
         if ((csi_params->row == 13) || (csi_params->row == 16))
-          nr_modulation(nr_gold_csi_rs[symb+1], csi_length, DMRS_MOD_ORDER, mod_csi[symb+1]);
+          nr_modulation(nr_gold_csi_rs(frame_parms, slot, symb + 1, csi_params->scramb_id),
+                        csi_length,
+                        DMRS_MOD_ORDER,
+                        mod_csi[symb + 1]);
       }
     }
   }

openair1/PHY/NR_TRANSPORT/nr_dci.c

@@ -95,13 +95,6 @@ void nr_generate_dci(PHY_VARS_gNB *gNB,
      * in time: by its first slot and its first symbol*/
     const nfapi_nr_dl_dci_pdu_t *dci_pdu = &pdcch_pdu_rel15->dci_pdu[d];
 
-    if(dci_pdu->ScramblingId != gNB->pdcch_gold_init) {
-      gNB->pdcch_gold_init = dci_pdu->ScramblingId;
-      nr_init_pdcch_dmrs(gNB, dci_pdu->ScramblingId);
-    }
-
-    uint32_t **gold_pdcch_dmrs = gNB->nr_gold_pdcch_dmrs[slot];
-
     cset_start_symb = pdcch_pdu_rel15->StartSymbolIndex;
     cset_nsymb = pdcch_pdu_rel15->DurationSymbols;
     dci_idx = 0;
@@ -131,9 +124,11 @@ void nr_generate_dci(PHY_VARS_gNB *gNB,
       
     /// DMRS QPSK modulation
     for (int symb=cset_start_symb; symb<cset_start_symb + pdcch_pdu_rel15->DurationSymbols; symb++) {
+      nr_modulation(nr_gold_pdcch(frame_parms->N_RB_DL, frame_parms->symbols_per_slot, dci_pdu->ScramblingId, slot, symb),
+                    dmrs_length,
+                    DMRS_MOD_ORDER,
+                    mod_dmrs[symb]); // Qm = 2 as DMRS is QPSK modulated
 
-      nr_modulation(gold_pdcch_dmrs[symb], dmrs_length, DMRS_MOD_ORDER, mod_dmrs[symb]); //Qm = 2 as DMRS is QPSK modulated
-      
 #ifdef DEBUG_PDCCH_DMRS
       if(dci_pdu->RNTI!=0xFFFF) {
         for (int i=0; i<dmrs_length>>1; i++)

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -76,12 +76,6 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
           rel15->BWPStart,rel15->BWPSize,rel15->rbStart,rel15->rbSize);
     const int n_dmrs = (rel15->BWPStart + rel15->rbStart + rel15->rbSize) * nb_re_dmrs;
 
-    if(rel15->dlDmrsScramblingId != gNB->pdsch_gold_init[rel15->SCID])  {
-      gNB->pdsch_gold_init[rel15->SCID] = rel15->dlDmrsScramblingId;
-      nr_init_pdsch_dmrs(gNB, rel15->SCID, rel15->dlDmrsScramblingId);
-    }
-
-    uint32_t ***pdsch_dmrs = gNB->nr_gold_pdsch_dmrs[slot];
     const int dmrs_symbol_map = rel15->dlDmrsSymbPos; // single DMRS: 010000100 Double DMRS 110001100
     const int xOverhead = 0;
     const int nb_re =
@@ -251,7 +245,8 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
             l_prime = 0;
           }
           /// DMRS QPSK modulation
-          nr_modulation(pdsch_dmrs[l_symbol][rel15->SCID],
+          NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+          nr_modulation(nr_gold_pdsch(fp->N_RB_DL, fp->symbols_per_slot, rel15->dlDmrsScramblingId, rel15->SCID, slot, l_symbol),
                         n_dmrs * DMRS_MOD_ORDER,
                         DMRS_MOD_ORDER,
                         (int16_t *)mod_dmrs); // Qm = 2 as DMRS is QPSK modulated
@@ -276,7 +271,11 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
           if(ptrs_symbol) {
             /* PTRS QPSK Modulation for each OFDM symbol in a slot */
             LOG_D(PHY, "Doing ptrs modulation for symbol %d, n_ptrs %d\n", l_symbol, n_ptrs);
-            nr_modulation(pdsch_dmrs[l_symbol][rel15->SCID], n_ptrs * DMRS_MOD_ORDER, DMRS_MOD_ORDER, (int16_t *)mod_ptrs);
+            NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+            nr_modulation(nr_gold_pdsch(fp->N_RB_DL, fp->symbols_per_slot, rel15->dlDmrsScramblingId, rel15->SCID, slot, l_symbol),
+                          n_ptrs * DMRS_MOD_ORDER,
+                          DMRS_MOD_ORDER,
+                          (int16_t *)mod_ptrs);
           }
         }
         uint16_t k = start_sc;

openair1/PHY/NR_TRANSPORT/nr_prs.c

@@ -3,18 +3,18 @@
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "PHY/sse_intrin.h"
-
+#include "openair1/PHY/NR_REFSIG/refsig_defs_ue.h"
 //#define DEBUG_PRS_MOD
 //#define DEBUG_PRS_MAP
 
 extern short nr_qpsk_mod_table[8];
 
-int nr_generate_prs(uint32_t **nr_gold_prs,
-                          c16_t *txdataF,
-                          int16_t amp,
-                          prs_config_t *prs_cfg,
-                          nfapi_nr_config_request_scf_t *config,
-                          NR_DL_FRAME_PARMS *frame_parms)
+int nr_generate_prs(int slot,
+                    c16_t *txdataF,
+                    int16_t amp,
+                    prs_config_t *prs_cfg,
+                    nfapi_nr_config_request_scf_t *config,
+                    NR_DL_FRAME_PARMS *frame_parms)
 {
   
   int k_prime = 0, k = 0, idx;
@@ -42,8 +42,9 @@ int nr_generate_prs(uint32_t **nr_gold_prs,
     k = (prs_cfg->REOffset+k_prime) % prs_cfg->CombSize + prs_cfg->RBOffset*12 + frame_parms->first_carrier_offset;
     
     // QPSK modulation
+    uint32_t *gold = nr_gold_prs(prs_cfg->NPRSID, slot, l);
     for (int m = 0; m < (12/prs_cfg->CombSize) * prs_cfg->NumRB; m++) {
-      idx = (((nr_gold_prs[l][(m<<1)>>5])>>((m<<1)&0x1f))&3);
+      idx = (((gold[(m << 1) >> 5]) >> ((m << 1) & 0x1f)) & 3);
       mod_prs[m<<1] = nr_qpsk_mod_table[idx<<1];
       mod_prs[(m<<1)+1] = nr_qpsk_mod_table[(idx<<1) + 1];
       

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -40,7 +40,7 @@
 
 NR_gNB_PHY_STATS_t *get_phy_stats(PHY_VARS_gNB *gNB, uint16_t rnti);
 
-int nr_generate_prs(uint32_t **nr_gold_prs,
+int nr_generate_prs(int slot,
                     c16_t *txdataF,
                     int16_t amp,
                     prs_config_t *prs_cfg,

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -68,7 +68,6 @@ c32_t nr_pbch_dmrs_correlation(const NR_DL_FRAME_PARMS *fp,
 
 int nr_pbch_channel_estimation(const NR_DL_FRAME_PARMS *fp,
                                const sl_nr_ue_phy_params_t *sl_phy_params,
-                               const uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD],
                                int estimateSz,
                                struct complex16 dl_ch_estimates[][estimateSz],
                                struct complex16 dl_ch_estimates_time[][fp->ofdm_symbol_size],

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -71,7 +71,6 @@ static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
                               int *ssb_index,
                               int *symbol_offset,
                               fapiPbch_t *result,
-                              const uint32_t nr_gold_pbch_ref[2][64][NR_PBCH_DMRS_LENGTH_DWORD],
                               const c16_t rxdataF[][frame_parms->samples_per_slot_wCP])
 {
   const int N_L = (frame_parms->Lmax == 4) ? 4 : 8;
@@ -90,7 +89,7 @@ static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
                                               i - pbch_initial_symbol,
                                               Nid_cell,
                                               ssb_start_subcarrier,
-                                              nr_gold_pbch_ref[hf][l],
+                                              nr_gold_pbch(frame_parms->Lmax, Nid_cell, hf, l),
                                               rxdataF);
         csum(cumul, cumul, meas);
       }
@@ -110,7 +109,6 @@ static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
     for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
       nr_pbch_channel_estimation(frame_parms,
                                  NULL,
-                                 nr_gold_pbch_ref,
                                  estimateSz,
                                  dl_ch_estimates,
                                  dl_ch_estimates_time,
@@ -277,9 +275,7 @@ void nr_scan_ssb(void *arg)
 #endif
     ssbInfo->freqOffset = freq_offset_pss + freq_offset_sss;
 
-    uint32_t nr_gold_pbch_ref[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
     if (ssbInfo->syncRes.cell_detected) { // we got sss channel
-      nr_gold_pbch(nr_gold_pbch_ref, ssbInfo->nidCell, fp->Lmax);
       ssbInfo->syncRes.cell_detected = nr_pbch_detection(ssbInfo->proc,
                                                          ssbInfo->fp,
                                                          ssbInfo->nidCell,
@@ -289,7 +285,6 @@ void nr_scan_ssb(void *arg)
                                                          &ssbInfo->ssbIndex,
                                                          &ssbInfo->symbolOffset,
                                                          &ssbInfo->pbchResult,
-                                                         nr_gold_pbch_ref,
                                                          rxdataF); // start pbch detection at first symbol after pss
     }
   }
@@ -400,7 +395,6 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc,
       // and we do not know yet in which slot it goes.
       compensate_freq_offset(ue->common_vars.rxdata, fp, res.freqOffset, res.syncRes.frame_id);
     }
-    nr_gold_pbch(ue->nr_gold_pbch, fp->Nid_cell, fp->Lmax);
     // sync at symbol ue->symbol_offset
     // computing the offset wrt the beginning of the frame
     int mu = fp->numerology_index;
@@ -413,24 +407,6 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc,
     // the n_frames we got sync
     ue->init_sync_frame = n_frames - 1 - res.syncRes.frame_id;
 
-    // compute the scramblingID_pdcch and the gold pdcch
-    ue->scramblingID_pdcch = fp->Nid_cell;
-    nr_gold_pdcch(ue, fp->Nid_cell);
-
-    // compute the scrambling IDs for PDSCH DMRS
-    for (int i = 0; i < NR_NB_NSCID; i++) {
-      ue->scramblingID_dlsch[i] = fp->Nid_cell;
-      nr_gold_pdsch(ue, i, ue->scramblingID_dlsch[i]);
-    }
-
-    nr_init_csi_rs(fp, ue->nr_csi_info->nr_gold_csi_rs, fp->Nid_cell);
-
-    // initialize the pusch dmrs
-    for (int i = 0; i < NR_NB_NSCID; i++) {
-      ue->scramblingID_ulsch[i] = fp->Nid_cell;
-      nr_init_pusch_dmrs(ue, ue->scramblingID_ulsch[i], i);
-    }
-
     // we also need to take into account the shift by samples_per_frame in case the if is true
     if (res.ssbOffset < sync_pos_frame) {
       res.syncRes.rx_offset = fp->samples_per_frame - sync_pos_frame + res.ssbOffset;

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c

@@ -464,7 +464,6 @@ nr_initial_sync_t sl_nr_slss_search(PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc,
         for (int symbol = 0; symbol < SL_NR_NUMSYM_SLSS_NORMAL_CP - 1;) {
           nr_pbch_channel_estimation(frame_parms,
                                      &UE->SL_UE_PHY_PARAMS,
-                                     UE->nr_gold_pbch,
                                      rxdataF_sz,
                                      dl_ch_estimates,
                                      dl_ch_estimates_time,

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -240,12 +240,6 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
   /////////////////////////DMRS Modulation/////////////////////////
   ///////////
 
-  if(pusch_pdu->ul_dmrs_scrambling_id != UE->scramblingID_ulsch[pusch_pdu->scid])  {
-    UE->scramblingID_ulsch[pusch_pdu->scid] = pusch_pdu->ul_dmrs_scrambling_id;
-    nr_init_pusch_dmrs(UE, pusch_pdu->scid, pusch_pdu->ul_dmrs_scrambling_id);
-  }
-
-  uint32_t ***pusch_dmrs = UE->nr_gold_pusch_dmrs[slot];
   uint16_t n_dmrs = (pusch_pdu->bwp_start + start_rb + nb_rb)*((dmrs_type == pusch_dmrs_type1) ? 6:4);
   c16_t mod_dmrs[n_dmrs] __attribute((aligned(16)));
 
@@ -382,7 +376,13 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
           // TODO: performance improvement, we can skip the modulation of DMRS symbols outside the bandwidth part
           // Perform this on gold sequence, not required when SC FDMA operation is done,
           LOG_D(PHY,"DMRS in symbol %d\n",l);
-          nr_modulation(pusch_dmrs[l][pusch_pdu->scid],
+          nr_modulation(nr_gold_pusch(frame_parms->N_RB_UL,
+                                      frame_parms->symbols_per_slot,
+                                      pusch_pdu->ul_dmrs_scrambling_id,
+                                      pusch_pdu->scid,
+
+                                      slot,
+                                      l),
                         n_dmrs * 2,
                         DMRS_MOD_ORDER,
                         (int16_t *)mod_dmrs); // currently only codeword 0 is modulated. Qm = 2 as DMRS is QPSK modulated
@@ -395,7 +395,16 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
 
         if(is_ptrs_symbol(l, ulsch_ue->ptrs_symbols)) {
           is_ptrs_sym = 1;
-          nr_modulation(pusch_dmrs[l][pusch_pdu->scid], nb_rb, DMRS_MOD_ORDER, (int16_t *)mod_ptrs);
+          nr_modulation(nr_gold_pusch(frame_parms->N_RB_UL,
+                                      frame_parms->symbols_per_slot,
+                                      pusch_pdu->ul_dmrs_scrambling_id,
+                                      pusch_pdu->scid,
+
+                                      slot,
+                                      l),
+                        nb_rb,
+                        DMRS_MOD_ORDER,
+                        (int16_t *)mod_ptrs);
         }
       }
 

openair1/PHY/defs_gNB.h

@@ -607,24 +607,9 @@ typedef struct PHY_VARS_gNB_s {
   // PUCCH0 Look-up table for cyclic-shifts
   NR_gNB_PUCCH0_LUT_t pucch0_lut;
 
-  /// PBCH DMRS sequence
-  uint32_t nr_gold_pbch_dmrs[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
-
   /// PBCH interleaver
   uint8_t nr_pbch_interleaver[NR_POLAR_PBCH_PAYLOAD_BITS];
 
-  /// PDCCH DMRS sequence
-  uint32_t ***nr_gold_pdcch_dmrs;
-
-  /// PDSCH DMRS sequence
-  uint32_t ****nr_gold_pdsch_dmrs;
-
-  /// PUSCH DMRS
-  uint32_t ****nr_gold_pusch_dmrs;
-
-  /// PRS sequence
-  uint32_t ****nr_gold_prs;
-
   /// PRACH root sequence
   c16_t X_u[64][839];
 
@@ -642,10 +627,6 @@ typedef struct PHY_VARS_gNB_s {
   /// counter to average prach energh over first 100 prach opportunities
   int prach_energy_counter;
 
-  int pdcch_gold_init;
-  int pdsch_gold_init[2];
-  int pusch_gold_init[2];
-
   int ap_N1;
   int ap_N2;
   int ap_XP;

openair1/PHY/defs_nr_UE.h

@@ -407,32 +407,7 @@ typedef struct PHY_VARS_NR_UE_s {
   uint32_t dmrs_pbch_bitmap_nr[DMRS_PBCH_I_SSB][DMRS_PBCH_N_HF][DMRS_BITMAP_SIZE];
 
 #endif
-
-
-  /// PBCH DMRS sequence
-  uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
-
-  /// PDSCH DMRS
-  uint32_t ****nr_gold_pdsch[NUMBER_OF_CONNECTED_eNB_MAX];
-
-  // Scrambling IDs used in PDSCH DMRS
-  uint16_t scramblingID_dlsch[2];
-
   // Scrambling IDs used in PUSCH DMRS
-  uint16_t scramblingID_ulsch[2];
-
-  /// PDCCH DMRS
-  uint32_t ***nr_gold_pdcch[NUMBER_OF_CONNECTED_eNB_MAX];
-
-  // Scrambling IDs used in PDCCH DMRS
-  uint16_t scramblingID_pdcch;
-
-  /// PUSCH DMRS sequence
-  uint32_t ****nr_gold_pusch_dmrs;
-
-  // PRS sequence per gNB, per resource
-  uint32_t *****nr_gold_prs;
-
   c16_t X_u[64][839];
 
   // flag to activate PRB based averaging of channel estimates
@@ -465,15 +440,15 @@ typedef struct PHY_VARS_NR_UE_s {
   int dlsch_ra_errors[NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_p_received[NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_p_errors[NUMBER_OF_CONNECTED_gNB_MAX];
-  int dlsch_mch_received_sf[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mch_received[NUMBER_OF_CONNECTED_gNB_MAX];
+  int current_dlsch_cqi[NUMBER_OF_CONNECTED_gNB_MAX];
+  int dlsch_mch_received_sf[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mcch_received[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mtch_received[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mcch_errors[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mtch_errors[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mcch_trials[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
   int dlsch_mtch_trials[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_gNB_MAX];
-  int current_dlsch_cqi[NUMBER_OF_CONNECTED_gNB_MAX];
   uint8_t               decode_SIB;
   uint8_t               decode_MIB;
   uint8_t               init_sync_frame;

openair1/PHY/defs_nr_common.h

@@ -122,8 +122,6 @@ typedef struct {
 } nr_srs_info_t;
 
 typedef struct {
-  uint16_t csi_gold_init;
-  uint32_t ***nr_gold_csi_rs;
   uint8_t csi_rs_generated_signal_bits;
   int32_t **csi_rs_generated_signal;
   bool csi_im_meas_computed;

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -108,20 +108,13 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB,int frame,int slot, nfapi_nr_
   nr_generate_pss(&txdataF[0][txdataF_offset], gNB->TX_AMP, ssb_start_symbol, cfg, fp);
   nr_generate_sss(&txdataF[0][txdataF_offset], gNB->TX_AMP, ssb_start_symbol, cfg, fp);
 
-  if (fp->Lmax == 4)
-    nr_generate_pbch_dmrs(gNB->nr_gold_pbch_dmrs[n_hf][ssb_index & 7],
-                          &txdataF[0][txdataF_offset],
-                          gNB->TX_AMP,
-                          ssb_start_symbol,
-                          cfg,
-                          fp);
-  else
-    nr_generate_pbch_dmrs(gNB->nr_gold_pbch_dmrs[0][ssb_index & 7],
-                          &txdataF[0][txdataF_offset],
-                          gNB->TX_AMP,
-                          ssb_start_symbol,
-                          cfg,
-                          fp);
+  int hf = fp->Lmax == 4 ? n_hf : 0;
+  nr_generate_pbch_dmrs(nr_gold_pbch(fp->Lmax, gNB->gNB_config.cell_config.phy_cell_id.value, hf, ssb_index & 7),
+                        &txdataF[0][txdataF_offset],
+                        gNB->TX_AMP,
+                        ssb_start_symbol,
+                        cfg,
+                        fp);
 
 #if T_TRACER
   if (T_ACTIVE(T_GNB_PHY_MIB)) {
@@ -186,7 +179,7 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
       {
         slot_prs = (slot - i*prs_config->PRSResourceTimeGap + fp->slots_per_frame)%fp->slots_per_frame;
         LOG_D(PHY,"gNB_TX: frame %d, slot %d, slot_prs %d, PRS Resource ID %d\n",frame, slot, slot_prs, rsc_id);
-        nr_generate_prs(gNB->nr_gold_prs[rsc_id][slot_prs],&gNB->common_vars.txdataF[0][txdataF_offset], AMP, prs_config, cfg, fp);
+        nr_generate_prs(slot_prs, &gNB->common_vars.txdataF[0][txdataF_offset], AMP, prs_config, cfg, fp);
       }
     }
   }

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -878,7 +878,6 @@ int pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_
             start_meas(&ue->dlsch_channel_estimation_stats);
             nr_pbch_channel_estimation(&ue->frame_parms,
                                        NULL,
-                                       ue->nr_gold_pbch,
                                        estimateSz,
                                        dl_ch_estimates,
                                        dl_ch_estimates_time,
@@ -999,7 +998,7 @@ int pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_
     }
     dci_cnt = dci_cnt + nr_ue_pdcch_procedures(ue, proc, pdcch_est_size, pdcch_dl_ch_estimates, phy_data, n_ss, rxdataF);
   }
-  LOG_D(PHY,"[UE %d] Frame %d, nr_slot_rx %d: found %d DCIs\n", ue->Mod_id, frame_rx, nr_slot_rx, dci_cnt);
+  LOG_D(PHY, "[UE %d] Frame %d, nr_slot_rx %d: found %d DCIs\n", ue->Mod_id, frame_rx, nr_slot_rx, dci_cnt);
   phy_pdcch_config->nb_search_space = 0;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP_PDCCH, VCD_FUNCTION_OUT);
   return sampleShift;

openair1/SCHED_NR_UE/phy_procedures_nr_ue_sl.c

@@ -195,7 +195,6 @@ int psbch_pscch_processing(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, nr_phy_d
       start_meas(&sl_phy_params->channel_estimation_stats);
       nr_pbch_channel_estimation(fp,
                                  &ue->SL_UE_PHY_PARAMS,
-                                 ue->nr_gold_pbch,
                                  estimateSz,
                                  dl_ch_estimates,
                                  dl_ch_estimates_time,

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -840,18 +840,6 @@ int main(int argc, char **argv)
 
   init_nr_ue_transport(UE);
 
-  nr_gold_pbch(UE->nr_gold_pbch, frame_parms->Nid_cell, frame_parms->Lmax);
-
-  // compute the scramblingID_pdcch and the gold pdcch
-  UE->scramblingID_pdcch = frame_parms->Nid_cell;
-  nr_gold_pdcch(UE, frame_parms->Nid_cell);
-
-  // compute the scrambling IDs for PDSCH DMRS
-  for (int i = 0; i < 2; i++) {
-    UE->scramblingID_dlsch[i] = frame_parms->Nid_cell;
-    nr_gold_pdsch(UE, i, UE->scramblingID_dlsch[i]);
-  }
-
   nr_l2_init_ue(1);
   UE_mac = get_mac_inst(0);
   ue_init_config_request(UE_mac, mu);

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -617,8 +617,6 @@ int main(int argc, char **argv)
     exit(-1);
   }
 
-  nr_gold_pbch(UE->nr_gold_pbch, Nid_cell, frame_parms->Lmax);
-
   processingData_L1tx_t msgDataTx;
   // generate signal
   const uint32_t rxdataF_sz = UE->frame_parms.samples_per_slot_wCP;
@@ -802,7 +800,6 @@ int main(int argc, char **argv)
 
           nr_pbch_channel_estimation(&UE->frame_parms,
                                      &UE->SL_UE_PHY_PARAMS,
-                                     UE->nr_gold_pbch,
                                      estimateSz,
                                      dl_ch_estimates,
                                      dl_ch_estimates_time,

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -703,11 +703,6 @@ int main(int argc, char *argv[])
 
   init_nr_ue_transport(UE);
 
-  for(int n_scid = 0; n_scid<2; n_scid++) {
-    UE->scramblingID_ulsch[n_scid] = frame_parms->Nid_cell;
-    nr_init_pusch_dmrs(UE, frame_parms->Nid_cell, n_scid);
-  }
-
   //Configure UE
   nr_l2_init_ue(1);
   NR_UE_MAC_INST_t* UE_mac = get_mac_inst(0);