removing call from MAC to PHY to clear structures (now automatic clearing)

common/openairinterface5g_limits.h

@@ -15,6 +15,8 @@
 #        define NUMBER_OF_SCH_STATS_MAX 16
 #        define NUMBER_OF_NR_SCH_STATS_MAX MAX_MOBILES_PER_GNB
 
+#        define NUMBER_FRAMES_PHY_UE_INACTIVE 10
+
 #define MAX_MANAGED_ENB_PER_MOBILE  2
 #define MAX_MANAGED_GNB_PER_MOBILE  2
 

executables/nr-gnb.c

@@ -128,7 +128,9 @@ void tx_func(void *param) {
 
 }
 
-void rx_func(void *param) {
+void rx_func(void *param)
+{
+
   processingData_L1_t *info = (processingData_L1_t *) param;
   PHY_VARS_gNB *gNB = info->gNB;
   int frame_rx = info->frame_rx;
@@ -173,46 +175,15 @@ void rx_func(void *param) {
 
   T(T_GNB_PHY_DL_TICK, T_INT(gNB->Mod_id), T_INT(frame_tx), T_INT(slot_tx));
 
-  /* hack to remove UEs */
-  extern int rnti_to_remove[10];
-  extern volatile int rnti_to_remove_count;
-  extern pthread_mutex_t rnti_to_remove_mutex;
-  if (pthread_mutex_lock(&rnti_to_remove_mutex)) exit(1);
-  int up_removed = 0;
-  int down_removed = 0;
-  int pucch_removed = 0;
-  for (int i = 0; i < rnti_to_remove_count; i++) {
-    LOG_W(NR_PHY, "to remove rnti 0x%04x\n", rnti_to_remove[i]);
-    void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch);
-    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]->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]->harq_processes[h]->status = NR_SCH_IDLE;
-          gNB->ulsch[j]->harq_processes[h]->round  = 0;
-          gNB->ulsch[j]->harq_processes[h]->handled = 0;
-        }
-        up_removed++;
-      }
-
-    for (j = 0; j < gNB->max_nb_pucch; j++)
-      if (gNB->pucch[j]->active > 0 &&
-          gNB->pucch[j]->pucch_pdu.rnti == rnti_to_remove[i]) {
-        gNB->pucch[j]->active = 0;
-        gNB->pucch[j]->pucch_pdu.rnti = 0;
-        pucch_removed++;
-      }
+  // disactivate PHY stats if UE is inactive for more than 10 frames
+  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
+    NR_gNB_PHY_STATS_t *stats = &gNB->phy_stats[i];
+    if(stats->active && (frame_rx > (stats->frame + NUMBER_FRAMES_PHY_UE_INACTIVE) % 1024))
+      stats->active = false;
   }
-  if (rnti_to_remove_count) LOG_W(NR_PHY, "to remove rnti_to_remove_count=%d, up_removed=%d down_removed=%d pucch_removed=%d\n", rnti_to_remove_count, up_removed, down_removed, pucch_removed);
-  rnti_to_remove_count = 0;
-  if (pthread_mutex_unlock(&rnti_to_remove_mutex)) exit(1);
 
   // RX processing
-  int rx_slot_type         = nr_slot_select(cfg,frame_rx,slot_rx);
+  int rx_slot_type = nr_slot_select(cfg,frame_rx,slot_rx);
   if (rx_slot_type == NR_UPLINK_SLOT || rx_slot_type == NR_MIXED_SLOT) {
     // UE-specific RX processing for subframe n
     // TODO: check if this is correct for PARALLEL_RU_L1_TRX_SPLIT

openair1/PHY/INIT/nr_init.c

@@ -77,6 +77,28 @@ void init_ul_delay_table(NR_DL_FRAME_PARMS *fp)
   }
 }
 
+NR_gNB_PHY_STATS_t *get_phy_stats(PHY_VARS_gNB *gNB, uint16_t rnti)
+{
+   NR_gNB_PHY_STATS_t *stats;
+   int first_free = -1;
+   for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
+     stats = &gNB->phy_stats[i];
+     if (stats->active && stats->rnti == rnti)
+       return stats;
+     else if (!stats->active && first_free == -1)
+       first_free = i;
+   }
+   // new stats
+   AssertFatal(first_free >= 0, "PHY statistics list is full\n");
+   stats = &gNB->phy_stats[first_free];
+   stats->active = true;
+   stats->rnti = rnti;
+   memset((void*)&stats->dlsch_stats, 0, sizeof(stats->dlsch_stats));
+   memset((void*)&stats->ulsch_stats, 0, sizeof(stats->ulsch_stats));
+   memset((void*)&stats->uci_stats, 0, sizeof(stats->uci_stats));
+   return(stats);
+}
+
 int init_codebook_gNB(PHY_VARS_gNB *gNB) {
 
   if(gNB->frame_parms.nb_antennas_tx>1){

openair1/PHY/NR_ESTIMATION/nr_measurements_gNB.c

@@ -38,7 +38,7 @@
 
 extern openair0_config_t openair0_cfg[MAX_CARDS];
 
-void nr_est_timing_advance_pusch(const NR_DL_FRAME_PARMS *frame_parms, const int32_t *ul_ch_estimates_time, struct delay_s *delay)
+void nr_est_timing_advance_pusch(const NR_DL_FRAME_PARMS *frame_parms, const int32_t *ul_ch_estimates_time, NR_ULSCH_delay_t *delay)
 {
   int max_pos = delay->pusch_delay_max_pos;
   int max_val = delay->pusch_delay_max_val;
@@ -208,19 +208,20 @@ void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot, int first_symb,int num_symb
 //
 // Todo:
 // - averaging IIR filter for RX power and noise
-void nr_gnb_measurements(PHY_VARS_gNB *gNB, uint8_t ulsch_id, unsigned char harq_pid, unsigned char symbol, uint8_t nrOfLayers){
+void nr_gnb_measurements(PHY_VARS_gNB *gNB, uint8_t ulsch_id, unsigned char harq_pid, unsigned char symbol, uint8_t nrOfLayers)
+{
 
   int rx_power_tot[NUMBER_OF_NR_ULSCH_MAX];
   int rx_power[NUMBER_OF_NR_ULSCH_MAX][NB_ANTENNAS_RX];
   unsigned short rx_power_avg_dB[NUMBER_OF_NR_ULSCH_MAX];
   unsigned short rx_power_tot_dB[NUMBER_OF_NR_ULSCH_MAX];
 
-  double             rx_gain = openair0_cfg[0].rx_gain[0];
-  double      rx_gain_offset = openair0_cfg[0].rx_gain_offset[0];
+  double rx_gain = openair0_cfg[0].rx_gain[0];
+  double rx_gain_offset = openair0_cfg[0].rx_gain_offset[0];
   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]->harq_processes[harq_pid]->ulsch_pdu.rb_size;
+  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  int ch_offset = fp->ofdm_symbol_size * symbol;
+  int N_RB_UL = gNB->ulsch[ulsch_id]->harq_process->ulsch_pdu.rb_size;
 
   rx_power_tot[ulsch_id] = 0;
 

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -187,7 +187,8 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 
   c16_t ul_ls_est[symbolSize] __attribute__((aligned(32)));
   memset(ul_ls_est, 0, sizeof(c16_t) * symbolSize);
-  memset(&gNB->measurements.delay[ul_id], 0, sizeof(gNB->measurements.delay[ul_id]));
+  NR_ULSCH_delay_t *delay = &gNB->ulsch[ul_id]->delay;
+  memset(&delay, 0, sizeof(delay));
 
   for (int aarx=0; aarx<gNB->frame_parms.nb_antennas_rx; aarx++) {
     c16_t *rxdataF = (c16_t *)&gNB->common_vars.rxdataF[aarx][symbol_offset];
@@ -232,13 +233,13 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
                 (int16_t *) ul_ls_est,
                 (int16_t *) gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx]);
 
-      nr_est_timing_advance_pusch(&gNB->frame_parms, gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx], &gNB->measurements.delay[ul_id]);
-      int delay = gNB->measurements.delay[ul_id].pusch_est_delay;
-      int delay_idx = get_delay_idx(delay);
+      nr_est_timing_advance_pusch(&gNB->frame_parms, gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx], delay);
+      int pusch_delay = delay->pusch_est_delay;
+      int delay_idx = get_delay_idx(pusch_delay);
       c16_t *ul_delay_table = gNB->frame_parms.ul_delay_table[delay_idx];
 
 #ifdef DEBUG_PUSCH
-      printf("Estimated delay = %i\n", delay >> 1);
+      printf("Estimated delay = %i\n", pusch_delay >> 1);
 #endif
 
       pilot_cnt = 0;
@@ -277,7 +278,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
       // Revert delay
       pilot_cnt = 0;
       ul_ch = &ul_ch_estimates[p * gNB->frame_parms.nb_antennas_rx + aarx][ch_offset];
-      int inv_delay_idx = get_delay_idx(-delay);
+      int inv_delay_idx = get_delay_idx(-pusch_delay);
       c16_t *ul_inv_delay_table = gNB->frame_parms.ul_delay_table[inv_delay_idx];
       for (int n = 0; n < 3 * nb_rb_pusch; n++) {
         for (int k_line = 0; k_line <= 1; k_line++) {
@@ -311,9 +312,9 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 
       // Delay compensation
       freq2time(symbolSize, (int16_t *)ul_ls_est, (int16_t *)gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx]);
-      nr_est_timing_advance_pusch(&gNB->frame_parms, gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx], &gNB->measurements.delay[ul_id]);
-      int delay = gNB->measurements.delay[ul_id].pusch_est_delay;
-      int delay_idx = get_delay_idx(-delay);
+      nr_est_timing_advance_pusch(&gNB->frame_parms, gNB->pusch_vars[ul_id]->ul_ch_estimates_time[aarx], delay);
+      int pusch_delay = delay->pusch_est_delay;
+      int delay_idx = get_delay_idx(-pusch_delay);
       c16_t *ul_delay_table = gNB->frame_parms.ul_delay_table[delay_idx];
       for (int n = 0; n < nb_rb_pusch * NR_NB_SC_PER_RB; n++) {
         ul_ch[n] = c16mulShift(ul_ls_est[n], ul_delay_table[n % 6], 8);

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -55,7 +55,7 @@ void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot,int first_symb,int num_symb)
 
 void nr_gnb_measurements(PHY_VARS_gNB *gNB, uint8_t ulsch_id, unsigned char harq_pid, unsigned char symbol, uint8_t nrOfLayers);
 
-void nr_est_timing_advance_pusch(const NR_DL_FRAME_PARMS *frame_parms, const int32_t *ul_ch_estimates_time, struct delay_s *delay);
+void nr_est_timing_advance_pusch(const NR_DL_FRAME_PARMS *frame_parms, const int32_t *ul_ch_estimates_time, NR_ULSCH_delay_t *delay);
 
 int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms,
                               const int32_t srs_estimated_channel_time[][frame_parms->ofdm_symbol_size]);

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -568,20 +568,21 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
 
 void dump_pdsch_stats(FILE *fd,PHY_VARS_gNB *gNB) {
 
-  for (int i=0;i<NUMBER_OF_NR_SCH_STATS_MAX;i++)
-    if (gNB->dlsch_stats[i].rnti > 0 && gNB->dlsch_stats[i].frame != gNB->dlsch_stats[i].dump_frame) {
-      gNB->dlsch_stats[i].dump_frame = gNB->dlsch_stats[i].frame;
+  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
+    NR_gNB_PHY_STATS_t *stats = &gNB->phy_stats[i];
+    if (stats->active && stats->frame != stats->dlsch_stats.dump_frame) {
+      stats->dlsch_stats.dump_frame = stats->frame;
       fprintf(fd,"DLSCH RNTI %x: current_Qm %d, current_RI %d, total_bytes TX %d\n",
-	    gNB->dlsch_stats[i].rnti,
-	    gNB->dlsch_stats[i].current_Qm,
-	    gNB->dlsch_stats[i].current_RI,
-	    gNB->dlsch_stats[i].total_bytes_tx);
+              stats->rnti,
+              stats->dlsch_stats.current_Qm,
+              stats->dlsch_stats.current_RI,
+              stats->dlsch_stats.total_bytes_tx);
     }
-
+  }
 }
 
-void clear_pdsch_stats(PHY_VARS_gNB *gNB) {
-
-  for (int i = 0;i < NUMBER_OF_NR_SCH_STATS_MAX; i++)
-    memset((void*)&gNB->dlsch_stats[i],0,sizeof(gNB->dlsch_stats[i]));
+void clear_pdsch_stats(PHY_VARS_gNB *gNB)
+{
+  for (int i = 0; i < MAX_MOBILES_PER_GNB;i++)
+    memset((void*)&gNB->phy_stats[i].dlsch_stats,0,sizeof(gNB->phy_stats[i].dlsch_stats));
 }

openair1/PHY/NR_TRANSPORT/nr_dlsch.h

@@ -52,8 +52,6 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
 
 void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
 
-void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch);
-
 int16_t find_nr_dlsch(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type);
 
 NR_gNB_SCH_STATS_t *find_nr_dlsch_stats(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type);

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -167,7 +167,6 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
 
 void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch) {
   AssertFatal(dlsch!=NULL,"dlsch is null\n");
-  dlsch->rnti = 0;
   dlsch->active = 0;
 }
 
@@ -280,7 +279,8 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
 		      unsigned char * output,
                       time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput,
                       time_stats_t *dlsch_rate_matching_stats,time_stats_t *dlsch_interleaving_stats,
-                      time_stats_t *dlsch_segmentation_stats) {
+                      time_stats_t *dlsch_segmentation_stats)
+{
   encoder_implemparams_t impp;
   impp.output=output;
   unsigned int crc=1;
@@ -289,29 +289,18 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_IN);
   uint32_t A = rel15->TBSize[0]<<3;
   unsigned char *a=harq->pdu;
-  if ( rel15->rnti != SI_RNTI)
+  if (rel15->rnti != SI_RNTI)
     trace_NRpdu(DIRECTION_DOWNLINK, a, rel15->TBSize[0], WS_C_RNTI, rel15->rnti, frame, slot,0, 0);
 
-  NR_gNB_SCH_STATS_t *stats=NULL;
-  int first_free=-1;
+  NR_gNB_PHY_STATS_t *phy_stats = NULL;
+  if (rel15->rnti != 0xFFFF)
+    phy_stats = get_phy_stats(gNB, rel15->rnti);
 
-  for (int i=0; i<NUMBER_OF_NR_SCH_STATS_MAX; i++) {
-    if (gNB->dlsch_stats[i].rnti == 0 && first_free == -1) {
-      first_free = i;
-      stats=&gNB->dlsch_stats[i];
-    }
-
-    if (gNB->dlsch_stats[i].rnti == rel15->rnti) {
-      stats=&gNB->dlsch_stats[i];
-      break;
-    }
-  }
-
-  if (stats) {
-    stats->rnti = rel15->rnti;
-    stats->total_bytes_tx += rel15->TBSize[0];
-    stats->current_RI   = rel15->nrOfLayers;
-    stats->current_Qm   = rel15->qamModOrder[0];
+  if (phy_stats) {
+    phy_stats->frame = frame;
+    phy_stats->dlsch_stats.total_bytes_tx += rel15->TBSize[0];
+    phy_stats->dlsch_stats.current_RI = rel15->nrOfLayers;
+    phy_stats->dlsch_stats.current_Qm = rel15->qamModOrder[0];
   }
 
   int max_bytes = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*rel15->nrOfLayers*1056;

openair1/PHY/NR_TRANSPORT/nr_dlsch_tools.c

@@ -46,14 +46,15 @@ void nr_emulate_dlsch_payload(uint8_t* pdu, uint16_t size) {
 
 void nr_fill_dlsch(processingData_L1tx_t *msgTx,
                    nfapi_nr_dl_tti_pdsch_pdu *pdsch_pdu,
-                   uint8_t *sdu) {
+                   uint8_t *sdu)
+{
 
   NR_gNB_DLSCH_t  *dlsch = msgTx->dlsch[msgTx->num_pdsch_slot][0];
   NR_DL_gNB_HARQ_t *harq  = &dlsch->harq_process;
   /// DLSCH struct
   memcpy((void*)&harq->pdsch_pdu, (void*)pdsch_pdu, sizeof(nfapi_nr_dl_tti_pdsch_pdu));
   msgTx->num_pdsch_slot++;
-  AssertFatal(sdu!=NULL,"sdu is null\n");
+  AssertFatal(sdu != NULL,"sdu is null\n");
   harq->pdu = sdu;
 }
 

openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h

@@ -40,7 +40,6 @@
 
 #include "PHY/defs_nr_common.h"
 
-
 void nr_group_sequence_hopping(pucch_GroupHopping_t PUCCH_GroupHopping,
                                uint32_t n_id,
                                uint8_t n_hop,

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -38,6 +38,7 @@
 
 #define NR_PBCH_PDU_BITS 24
 
+NR_gNB_PHY_STATS_t *get_phy_stats(PHY_VARS_gNB *gNB, uint16_t rnti);
 
 int nr_generate_prs(uint32_t **nr_gold_prs,
                     c16_t *txdataF,
@@ -312,19 +313,9 @@ void nr_fill_pucch(PHY_VARS_gNB *gNB,
                    int slot,
                    nfapi_nr_pucch_pdu_t *pucch_pdu);
 
-int nr_find_pucch(uint16_t rnti,
-                  int frame,
-                  int slot,
-                  PHY_VARS_gNB *gNB);
-
 NR_gNB_SRS_t *new_gNB_srs(void);
 void free_gNB_srs(NR_gNB_SRS_t *srs);
 
-int nr_find_srs(rnti_t rnti,
-                frame_t frame,
-                slot_t slot,
-                PHY_VARS_gNB *gNB);
-
 void nr_fill_srs(PHY_VARS_gNB *gNB,
                  frame_t frame,
                  slot_t slot,

openair1/PHY/NR_TRANSPORT/nr_ulsch.c

@@ -34,57 +34,63 @@
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
 #include "PHY/NR_TRANSPORT/nr_ulsch.h"
 
-int16_t find_nr_ulsch(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type) {
-
-  uint16_t i;
-  int16_t first_free_index=-1;
-
-  AssertFatal(gNB!=NULL,"gNB is null\n");
-  for (i = 0; i < NUMBER_OF_NR_ULSCH_MAX; i++) {
-    AssertFatal(gNB->ulsch[i]!=NULL,"gNB->ulsch[%d] 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]->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;
+int16_t find_nr_ulsch(PHY_VARS_gNB *gNB, uint16_t rnti, int pid, int frame)
+{
+
+  int16_t first_free_index = -1;
+  AssertFatal(gNB != NULL,"gNB is null\n");
+
+  for (int i = 0; i < NUMBER_OF_NR_ULSCH_MAX; i++) {
+    NR_gNB_ULSCH_t *ulsch = gNB->ulsch[i];
+    AssertFatal(ulsch != NULL, "gNB->ulsch[%d] is null\n", i);
+    if(!ulsch->active) {
+      if (first_free_index == -1)
+        first_free_index = i;
+    }
+    else {
+      // if there is already an active ULSCH for this RNTI and HARQ_PID
+      if ((ulsch->harq_pid == pid) && (ulsch->rnti == rnti))
+        return i;
+      // remove inactive ULSCH (from disconnected UEs)
+      else if ((frame > (ulsch->harq_process->frame + NUMBER_FRAMES_PHY_UE_INACTIVE) % 1024))
+        ulsch->active = false;
+    }
   }
-  if (type == SEARCH_EXIST) return -1;
-  if (first_free_index != -1)
-    gNB->ulsch[first_free_index]->rnti = 0;
   return first_free_index;
 }
 
 void nr_fill_ulsch(PHY_VARS_gNB *gNB,
                    int frame,
                    int slot,
-                   nfapi_nr_pusch_pdu_t *ulsch_pdu) {
-
+                   nfapi_nr_pusch_pdu_t *ulsch_pdu)
+{
  
-  int ulsch_id = find_nr_ulsch(ulsch_pdu->rnti,gNB,SEARCH_EXIST_OR_FREE);
+  int harq_pid = ulsch_pdu->pusch_data.harq_process_id;
+  int ulsch_id = find_nr_ulsch(gNB, ulsch_pdu->rnti, harq_pid, frame);
   AssertFatal((ulsch_id >= 0) && (ulsch_id < 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];
-  int harq_pid = ulsch_pdu->pusch_data.harq_process_id;
+
   ulsch->rnti = ulsch_pdu->rnti;
-  //ulsch->rnti_type;
-  ulsch->harq_mask |= 1<<harq_pid;
-
-  NR_UL_gNB_HARQ_t *harq = ulsch->harq_processes[harq_pid];
-  harq->frame=frame;
-  harq->slot=slot;
-  harq->handled = 0;
-  harq->status= NR_ACTIVE;
+  ulsch->harq_pid = harq_pid;
+  ulsch->handled = 0;
+  ulsch->active = true;
+
+  NR_UL_gNB_HARQ_t *harq = ulsch->harq_process;
+  harq->frame = frame;
+  harq->slot = slot;
   harq->new_rx = ulsch_pdu->pusch_data.new_data_indicator;
-  LOG_D(PHY,"ULSCH ID %d RNTI %x HARQ PID %d new data indicator %d\n",ulsch_id, ulsch_pdu->rnti, harq_pid, ulsch_pdu->pusch_data.new_data_indicator);
+  LOG_D(PHY,"%d.%d ULSCH ID %d RNTI %x HARQ PID %d new data indicator %d\n",
+        frame, slot, ulsch_id, ulsch_pdu->rnti, harq_pid, ulsch_pdu->pusch_data.new_data_indicator);
   if (harq->new_rx)
     harq->round = 0;
   else
     harq->round++;
 
-  memcpy((void*)&ulsch->harq_processes[harq_pid]->ulsch_pdu, (void*)ulsch_pdu, sizeof(nfapi_nr_pusch_pdu_t));
-
-  LOG_D(PHY,"Initializing nFAPI for ULSCH, UE %d, harq_pid %d\n",ulsch_id,harq_pid);
+  memcpy((void*)&ulsch->harq_process->ulsch_pdu, (void*)ulsch_pdu, sizeof(nfapi_nr_pusch_pdu_t));
 
+  LOG_D(PHY,"Initializing nFAPI for ULSCH, UE %d, harq_pid %d\n", ulsch_id, harq_pid);
 }
 
 void nr_ulsch_unscrambling(int16_t* llr, uint32_t size, uint32_t Nid, uint32_t n_RNTI)
@@ -93,10 +99,10 @@ void nr_ulsch_unscrambling(int16_t* llr, uint32_t size, uint32_t Nid, uint32_t n
 }
 
 void nr_ulsch_layer_demapping(int16_t *llr_cw,
-				     uint8_t Nl,
-				     uint8_t mod_order,
-				     uint32_t length,
-				     int16_t **llr_layers) 
+                              uint8_t Nl,
+                              uint8_t mod_order,
+                              uint32_t length,
+                              int16_t **llr_layers)
 {
 
   switch (Nl) {
@@ -115,63 +121,51 @@ void nr_ulsch_layer_demapping(int16_t *llr_cw,
       }
       break;
   default:
-  AssertFatal(0, "Not supported number of layers %d\n", Nl);
+    AssertFatal(0, "Not supported number of layers %d\n", Nl);
   }
 }
 
-void dump_pusch_stats(FILE *fd,PHY_VARS_gNB *gNB) {
-
-  for (int i = 0;i < NUMBER_OF_NR_SCH_STATS_MAX;i++) {
+void dump_pusch_stats(FILE *fd, PHY_VARS_gNB *gNB)
+{
 
-    if (gNB->ulsch_stats[i].rnti>0 && gNB->ulsch_stats[i].frame != gNB->ulsch_stats[i].dump_frame) {
-      gNB->ulsch_stats[i].dump_frame = gNB->ulsch_stats[i].frame; 
-      for (int aa=0;aa<gNB->frame_parms.nb_antennas_rx;aa++)
-          if (aa==0) fprintf(fd,"ULSCH RNTI %4x, %d.%d: ulsch_power[%d] %d,%d ulsch_noise_power[%d] %d.%d, sync_pos %d\n",
-                                     gNB->ulsch_stats[i].rnti,gNB->ulsch_stats[i].frame,gNB->ulsch_stats[i].dump_frame,
-                                     aa,gNB->ulsch_stats[i].power[aa]/10,gNB->ulsch_stats[i].power[aa]%10,
-                                     aa,gNB->ulsch_stats[i].noise_power[aa]/10,gNB->ulsch_stats[i].noise_power[aa]%10,
-                                     gNB->ulsch_stats[i].sync_pos);
-          else       fprintf(fd,"                  ulsch_power[%d] %d.%d, ulsch_noise_power[%d] %d.%d\n",
-                                     aa,gNB->ulsch_stats[i].power[aa]/10,gNB->ulsch_stats[i].power[aa]%10,
-                                     aa,gNB->ulsch_stats[i].noise_power[aa]/10,gNB->ulsch_stats[i].noise_power[aa]%10);
+  for (int i = 0;i < MAX_MOBILES_PER_GNB; i++) {
+    NR_gNB_PHY_STATS_t *stats = &gNB->phy_stats[i];
+    if (stats->active && stats->frame != stats->ulsch_stats.dump_frame) {
+      stats->ulsch_stats.dump_frame = stats->frame;
+      for (int aa = 0; aa < gNB->frame_parms.nb_antennas_rx; aa++)
+        if (aa==0)
+          fprintf(fd,"ULSCH RNTI %4x, %d: ulsch_power[%d] %d,%d ulsch_noise_power[%d] %d.%d, sync_pos %d\n",
+                  stats->rnti, stats->frame,
+                  aa, stats->ulsch_stats.power[aa]/10, stats->ulsch_stats.power[aa]%10,
+                  aa, stats->ulsch_stats.noise_power[aa]/10, stats->ulsch_stats.noise_power[aa]%10,
+                  stats->ulsch_stats.sync_pos);
+        else
+          fprintf(fd,"                  ulsch_power[%d] %d.%d, ulsch_noise_power[%d] %d.%d\n",
+                  aa, stats->ulsch_stats.power[aa]/10, stats->ulsch_stats.power[aa]%10,
+                  aa, stats->ulsch_stats.noise_power[aa]/10, stats->ulsch_stats.noise_power[aa]%10);
 
 
       fprintf(fd,"                 round_trials %d(%1.1e):%d(%1.1e):%d(%1.1e):%d, DTX %d, current_Qm %d, current_RI %d, total_bytes RX/SCHED %d/%d\n",
-	    gNB->ulsch_stats[i].round_trials[0],
-	    (double)gNB->ulsch_stats[i].round_trials[1]/gNB->ulsch_stats[i].round_trials[0],
-	    gNB->ulsch_stats[i].round_trials[1],
-	    (double)gNB->ulsch_stats[i].round_trials[2]/gNB->ulsch_stats[i].round_trials[0],
-	    gNB->ulsch_stats[i].round_trials[2],
-	    (double)gNB->ulsch_stats[i].round_trials[3]/gNB->ulsch_stats[i].round_trials[0],
-	    gNB->ulsch_stats[i].round_trials[3],
-            gNB->ulsch_stats[i].DTX,
-	    gNB->ulsch_stats[i].current_Qm,
-	    gNB->ulsch_stats[i].current_RI,
-	    gNB->ulsch_stats[i].total_bytes_rx,
-	    gNB->ulsch_stats[i].total_bytes_tx);
+              stats->ulsch_stats.round_trials[0],
+              (double)stats->ulsch_stats.round_trials[1]/stats->ulsch_stats.round_trials[0],
+              stats->ulsch_stats.round_trials[1],
+              (double)stats->ulsch_stats.round_trials[2]/stats->ulsch_stats.round_trials[0],
+              stats->ulsch_stats.round_trials[2],
+              (double)stats->ulsch_stats.round_trials[3]/stats->ulsch_stats.round_trials[0],
+              stats->ulsch_stats.round_trials[3],
+              stats->ulsch_stats.DTX,
+              stats->ulsch_stats.current_Qm,
+              stats->ulsch_stats.current_RI,
+              stats->ulsch_stats.total_bytes_rx,
+              stats->ulsch_stats.total_bytes_tx);
     }
- }
+  }
 }
 
-void clear_pusch_stats(PHY_VARS_gNB *gNB) {
-
-  for (int i = 0; i < NUMBER_OF_NR_ULSCH_MAX; i++)
-    memset((void*)&gNB->ulsch_stats[i],0,sizeof(gNB->ulsch_stats[i]));
+void clear_pusch_stats(PHY_VARS_gNB *gNB)
+{
+  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++)
+    memset((void*)&gNB->phy_stats[i].ulsch_stats,0,sizeof(gNB->phy_stats[i].ulsch_stats));
 }
 
-NR_gNB_SCH_STATS_t *get_ulsch_stats(PHY_VARS_gNB *gNB,NR_gNB_ULSCH_t *ulsch) {
-   NR_gNB_SCH_STATS_t *stats=NULL;
-   int first_free=-1;
-   for (int i = 0; i < NUMBER_OF_NR_ULSCH_MAX; i++) {
-       if (gNB->ulsch_stats[i].rnti == 0 && first_free == -1) {
-          first_free = i;
-          stats=&gNB->ulsch_stats[i];
-       }
-       if (gNB->ulsch_stats[i].rnti == ulsch->rnti) {
-           stats=&gNB->ulsch_stats[i];
-           break;
-       }
-   }
-   return(stats);
-}
 

openair1/PHY/NR_TRANSPORT/nr_ulsch.h

@@ -82,7 +82,8 @@ void nr_ulsch_procedures(PHY_VARS_gNB *gNB,
                          int slot_rx,
                          int UE_id,
                          uint8_t harq_pid);
-int16_t find_nr_ulsch(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type);
+
+int16_t find_nr_ulsch(PHY_VARS_gNB *gNB, uint16_t rnti, int pid, int frame);
 
 void dump_pusch_stats(FILE *fd,PHY_VARS_gNB *gNB);
 

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -38,6 +38,7 @@
 #include "PHY/CODING/lte_interleaver_inline.h"
 #include "PHY/CODING/nrLDPC_extern.h"
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "PHY/NR_TRANSPORT/nr_transport_proto.h"
 #include "PHY/NR_TRANSPORT/nr_ulsch.h"
 #include "PHY/NR_TRANSPORT/nr_dlsch.h"
 #include "SCHED_NR/sched_nr.h"
@@ -65,21 +66,19 @@ void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr, uint16_t N_RB_UL)
     a_segments = a_segments/273 +1;
   }
 
-  for (int i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
-    if (ulsch->harq_processes[i]) {
-      if (ulsch->harq_processes[i]->b) {
-        free_and_zero(ulsch->harq_processes[i]->b);
-        ulsch->harq_processes[i]->b = NULL;
-      }
-      for (int r=0; r<a_segments; r++) {
-        free_and_zero(ulsch->harq_processes[i]->c[r]);
-        free_and_zero(ulsch->harq_processes[i]->d[r]);
-      }
-      free_and_zero(ulsch->harq_processes[i]->c);
-      free_and_zero(ulsch->harq_processes[i]->d);
-      free_and_zero(ulsch->harq_processes[i]);
-      ulsch->harq_processes[i] = NULL;
+  if (ulsch->harq_process) {
+    if (ulsch->harq_process->b) {
+      free_and_zero(ulsch->harq_process->b);
+      ulsch->harq_process->b = NULL;
+    }
+    for (int r = 0; r < a_segments; r++) {
+      free_and_zero(ulsch->harq_process->c[r]);
+      free_and_zero(ulsch->harq_process->d[r]);
     }
+    free_and_zero(ulsch->harq_process->c);
+    free_and_zero(ulsch->harq_process->d);
+    free_and_zero(ulsch->harq_process);
+    ulsch->harq_process = NULL;
   }
   free_and_zero(*ulschptr);
 }
@@ -88,8 +87,6 @@ void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr, uint16_t N_RB_UL)
 NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations, uint16_t N_RB_UL)
 {
 
-  NR_gNB_ULSCH_t *ulsch;
-  uint8_t i,r;
   uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS_PER_LAYER*NR_MAX_NB_LAYERS;  //number of segments to be allocated
 
   if (N_RB_UL != 273) {
@@ -97,70 +94,31 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations, uint16_t N_RB_UL)
     a_segments = a_segments/273 +1;
   }
 
-  uint32_t ulsch_bytes = a_segments*1056;  // allocated bytes per segment
-  ulsch = (NR_gNB_ULSCH_t *)malloc16_clear(sizeof(NR_gNB_ULSCH_t));
+  uint32_t ulsch_bytes = a_segments * 1056;  // allocated bytes per segment
+  NR_gNB_ULSCH_t *ulsch = (NR_gNB_ULSCH_t *)malloc16_clear(sizeof(NR_gNB_ULSCH_t));
 
   ulsch->max_ldpc_iterations = max_ldpc_iterations;
-
-  for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
-    ulsch->harq_processes[i] = (NR_UL_gNB_HARQ_t *)malloc16_clear(sizeof(NR_UL_gNB_HARQ_t));
-    ulsch->harq_processes[i]->b = (uint8_t*)malloc16_clear(ulsch_bytes);
-    ulsch->harq_processes[i]->c = (uint8_t**)malloc16_clear(a_segments*sizeof(uint8_t *));
-    ulsch->harq_processes[i]->d = (int16_t**)malloc16_clear(a_segments*sizeof(int16_t *));
-    for (r=0; r<a_segments; r++) {
-      ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16_clear(8448*sizeof(uint8_t));
-      ulsch->harq_processes[i]->d[r] = (int16_t*)malloc16_clear((68*384)*sizeof(int16_t));
-    }
+  ulsch->harq_pid = -1;
+  ulsch->active = false;
+
+  ulsch->harq_process = (NR_UL_gNB_HARQ_t *)malloc16_clear(sizeof(NR_UL_gNB_HARQ_t));
+  ulsch->harq_process->b = (uint8_t*)malloc16_clear(ulsch_bytes);
+  ulsch->harq_process->c = (uint8_t**)malloc16_clear(a_segments*sizeof(uint8_t *));
+  ulsch->harq_process->d = (int16_t**)malloc16_clear(a_segments*sizeof(int16_t *));
+  for (int r = 0; r < a_segments; r++) {
+    ulsch->harq_process->c[r] = (uint8_t*)malloc16_clear(8448*sizeof(uint8_t));
+    ulsch->harq_process->d[r] = (int16_t*)malloc16_clear((68*384)*sizeof(int16_t));
   }
-
   return(ulsch);
 }
 
-void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch)
-{
-
-
-  if (ulsch) {
-    ulsch->harq_mask = 0;
-    ulsch->rnti = 0;
-    ulsch->rnti_type = 0;
-    ulsch->max_ldpc_iterations = 0;
-    ulsch->last_iteration_cnt = 0;
-
-    for (int i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
-      if (ulsch->harq_processes[i]){
-        /// Nfapi ULSCH PDU
-        //nfapi_nr_ul_config_ulsch_pdu ulsch_pdu;
-        ulsch->harq_processes[i]->frame=0;
-        ulsch->harq_processes[i]->slot=0;
-        ulsch->harq_processes[i]->round=0;
-        ulsch->harq_processes[i]->status=NR_SCH_IDLE;
-        ulsch->harq_processes[i]->handled=0;
-        ulsch->harq_processes[i]->TBS=0;
-        /// Pointer to the payload (38.212 V15.4.0 section 5.1)
-        //uint8_t *b;
-        ulsch->harq_processes[i]->B=0;
-        /// Pointers to code blocks after code block segmentation and CRC attachment (38.212 V15.4.0 section 5.2.2)
-        //uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
-        ulsch->harq_processes[i]->K=0;
-        ulsch->harq_processes[i]->F=0;
-        ulsch->harq_processes[i]->C=0;
-        /// Pointers to code blocks after LDPC coding (38.212 V15.4.0 section 5.3.2)
-        //int16_t *d[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_ULSCH_SEGMENTS][3*8448];
-        ulsch->harq_processes[i]->E=0;
-      }
-    }
-  }
-}
-
 #ifdef PRINT_CRC_CHECK
   static uint32_t prnt_crc_cnt = 0;
 #endif
 
-void nr_processULSegment(void* arg) {
+void nr_processULSegment(void* arg)
+{
+
   ldpcDecode_t *rdata = (ldpcDecode_t*) arg;
   PHY_VARS_gNB *phy_vars_gNB = rdata->gNB;
   NR_UL_gNB_HARQ_t *ulsch_harq = rdata->ulsch_harq;
@@ -325,14 +283,14 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
                            uint8_t harq_pid,
                            uint32_t G)
 {
+
 #ifdef PRINT_CRC_CHECK
   prnt_crc_cnt++;
 #endif
-  
 
-  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];
+  NR_gNB_ULSCH_t *ulsch = phy_vars_gNB->ulsch[ULSCH_id];
+  NR_gNB_PUSCH *pusch = phy_vars_gNB->pusch_vars[ULSCH_id];
+  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
 
   if (!harq_process) {
     LOG_E(PHY,"ulsch_decoding.c: NULL harq_process pointer\n");
@@ -379,30 +337,18 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
     kc = 68;
   }
 
-  NR_gNB_SCH_STATS_t *stats=NULL;
-  int first_free=-1;
-  for (int i=0;i<NUMBER_OF_NR_SCH_STATS_MAX;i++) {
-    if (phy_vars_gNB->ulsch_stats[i].rnti == 0 && first_free == -1) {
-      first_free = i;
-      stats=&phy_vars_gNB->ulsch_stats[i];
-    }
-    if (phy_vars_gNB->ulsch_stats[i].rnti == ulsch->rnti) {
-      stats=&phy_vars_gNB->ulsch_stats[i];
-      break;
-    }
-  }
+  NR_gNB_PHY_STATS_t *stats = get_phy_stats(phy_vars_gNB, ulsch->rnti);
   if (stats) {
     stats->frame = frame;
-    stats->rnti = ulsch->rnti;
-    stats->round_trials[harq_process->round]++;
-    for (int aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
-      stats->power[aarx] = dB_fixed_x10(pusch->ulsch_power[aarx]);
-      stats->noise_power[aarx] = dB_fixed_x10(pusch->ulsch_noise_power[aarx]);
+    stats->ulsch_stats.round_trials[harq_process->round]++;
+    for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
+      stats->ulsch_stats.power[aarx] = dB_fixed_x10(pusch->ulsch_power[aarx]);
+      stats->ulsch_stats.noise_power[aarx] = dB_fixed_x10(pusch->ulsch_noise_power[aarx]);
     }
     if (harq_process->new_rx == 0) {
-      stats->current_Qm = Qm;
-      stats->current_RI = n_layers;
-      stats->total_bytes_tx += harq_process->TBS;
+      stats->ulsch_stats.current_Qm = Qm;
+      stats->ulsch_stats.current_RI = n_layers;
+      stats->ulsch_stats.total_bytes_tx += harq_process->TBS;
     }
   }
   if (A > 3824)
@@ -594,9 +540,8 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 
     if (harq_process->processedSegments == (harq_process->C)) {
       LOG_D(PHY, "[gNB %d] ULSCH: Setting ACK for slot %d TBS %d\n", phy_vars_gNB->Mod_id, harq_process->slot, harq_process->TBS);
-      harq_process->status = NR_SCH_IDLE;
+      ulsch->active = false;
       harq_process->round = 0;
-      ulsch->harq_mask &= ~(1 << harq_pid);
 
       LOG_D(PHY, "ULSCH received ok \n");
       nr_fill_indication(phy_vars_gNB, harq_process->frame, harq_process->slot, ULSCH_id, harq_pid, 0, 0);
@@ -608,10 +553,10 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
             harq_process->frame,
             harq_process->slot,
             harq_pid,
-            harq_process->status,
+            ulsch->active,
             harq_process->round,
             harq_process->TBS);
-      harq_process->handled = 1;
+      ulsch->handled = 1;
       no_iteration_ldpc = ulsch->max_ldpc_iterations + 1;
       LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
       nr_fill_indication(phy_vars_gNB, harq_process->frame, harq_process->slot, ULSCH_id, harq_pid, 1, 0);

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -1847,7 +1847,7 @@ void 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]->harq_processes[harq_pid]->ulsch_pdu;
+  nfapi_nr_pusch_pdu_t *rel15_ul = &gNB->ulsch[ulsch_id]->harq_process->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/srs_rx.c

@@ -56,43 +56,25 @@ void free_gNB_srs(NR_gNB_SRS_t *srs)
   free_and_zero(srs);
 }
 
-int nr_find_srs(rnti_t rnti,
-                frame_t frame,
-                slot_t slot,
-                PHY_VARS_gNB *gNB) {
-
-  AssertFatal(gNB!=NULL,"gNB is null\n");
-  int index = -1;
-
-  for (int i = 0; i < gNB->max_nb_srs; i++) {
-    AssertFatal(gNB->srs[i]!=NULL,"gNB->srs[%d] is null\n",i);
-    if ((gNB->srs[i]->active>0) &&
-        (gNB->srs[i]->srs_pdu.rnti==rnti) &&
-        (gNB->srs[i]->frame==frame) &&
-        (gNB->srs[i]->slot==slot)) return(i);
-    else if ((gNB->srs[i]->active == 0) && (index==-1)) index=i;
-  }
-
-  if (index==-1)
-    LOG_E(PHY,"SRS list is full\n");
-
-  return(index);
-}
-
 void nr_fill_srs(PHY_VARS_gNB *gNB,
                  frame_t frame,
                  slot_t slot,
-                 nfapi_nr_srs_pdu_t *srs_pdu) {
-
-  int id = nr_find_srs(srs_pdu->rnti,frame,slot,gNB);
-  AssertFatal((id >= 0) && (id < gNB->max_nb_srs),
-              "invalid id found for srs !!! rnti %04x id %d\n",srs_pdu->rnti,id);
+                 nfapi_nr_srs_pdu_t *srs_pdu)
+{
 
-  NR_gNB_SRS_t  *srs = gNB->srs[id];
-  srs->frame = frame;
-  srs->slot = slot;
-  srs->active = 1;
-  memcpy((void*)&srs->srs_pdu, (void*)srs_pdu, sizeof(nfapi_nr_srs_pdu_t));
+  bool found = false;
+  for (int i = 0; i < gNB->max_nb_srs; i++) {
+    if (gNB->srs[i]->active == 0) {
+      found = true;
+      NR_gNB_SRS_t  *srs = gNB->srs[i];
+      srs->frame = frame;
+      srs->slot = slot;
+      srs->active = 1;
+      memcpy((void*)&srs->srs_pdu, (void*)srs_pdu, sizeof(nfapi_nr_srs_pdu_t));
+      break;
+    }
+  }
+  AssertFatal(found, "SRS list is full\n");
 }
 
 int nr_get_srs_signal(PHY_VARS_gNB *gNB,

openair1/PHY/defs_gNB.h

@@ -97,9 +97,7 @@ typedef struct {
 } NR_gNB_CSIRS_t;
 
 typedef struct {
-  int frame;
   int dump_frame;
-  uint16_t rnti;
   int round_trials[8];
   int total_bytes_tx;
   int total_bytes_rx;
@@ -112,8 +110,6 @@ typedef struct {
 } NR_gNB_SCH_STATS_t;
 
 typedef struct {
-  int frame;
-  uint16_t rnti;
   int pucch0_sr_trials;
   int pucch0_sr_thres;
   int current_pucch0_sr_stat0;
@@ -132,6 +128,17 @@ typedef struct {
   int pucch2_DTX;
 } NR_gNB_UCI_STATS_t;
 
+typedef struct {
+  int frame;
+  uint16_t rnti;
+  bool active;
+  /// statistics for DLSCH measurement collection
+  NR_gNB_SCH_STATS_t dlsch_stats;
+  /// statistics for ULSCH measurement collection
+  NR_gNB_SCH_STATS_t ulsch_stats;
+  NR_gNB_UCI_STATS_t uci_stats;
+} NR_gNB_PHY_STATS_t;
+
 typedef struct {
   /// Pointers to variables related to DLSCH harq process
   NR_DL_gNB_HARQ_t harq_process;
@@ -141,12 +148,8 @@ typedef struct {
   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;
-  /// Allocated RNTI (0 means DLSCH_t is not currently used)
-  uint16_t rnti;
   /// Active flag for baseband transmitter processing
   uint8_t active;
-  /// HARQ process mask, indicates which processes are currently active
-  uint16_t harq_mask;
   /// Number of soft channel bits
   uint32_t G;
 } NR_gNB_DLSCH_t;
@@ -192,11 +195,7 @@ typedef struct {
   /// Index of current HARQ round for this DLSCH
   uint8_t round;
   bool new_rx;
-  /// Status Flag indicating for this ULSCH (idle,active,disabled)
-  NR_SCH_status_t status;
-  /// Flag to indicate that the UL configuration has been handled. Used to remove a stale ULSCH when frame wraps around
-  uint8_t handled;
-    /////////////////////// ulsch decoding ///////////////////////
+  /////////////////////// ulsch decoding ///////////////////////
   /// Transport block size (This is A from 38.212 V15.4.0 section 5.1)
   uint32_t TBS;
   /// Pointer to the payload (38.212 V15.4.0 section 5.1)
@@ -226,19 +225,31 @@ typedef struct {
 } NR_UL_gNB_HARQ_t;
 
 
+typedef struct {
+  /// Time shift in number of samples estimated based on DMRS-PUSCH
+  int pusch_est_delay;
+  /// Max position in OFDM symbol related to time shift estimation based on DMRS-PUSCH
+  int pusch_delay_max_pos;
+  /// Max value related to time shift estimation based on DMRS-PUSCH
+  int pusch_delay_max_val;
+} NR_ULSCH_delay_t;
+
 typedef struct {
   /// Pointers to 16 HARQ processes for the ULSCH
-  NR_UL_gNB_HARQ_t *harq_processes[NR_MAX_ULSCH_HARQ_PROCESSES];
+  NR_UL_gNB_HARQ_t *harq_process;
   /// HARQ process mask, indicates which processes are currently active
-  uint16_t harq_mask;
+  int harq_pid;
   /// Allocated RNTI for this ULSCH
   uint16_t rnti;
-  /// RNTI type
-  uint8_t rnti_type;
   /// Maximum number of LDPC iterations
   uint8_t max_ldpc_iterations;
   /// number of iterations used in last LDPC decoding
-  uint8_t last_iteration_cnt;  
+  uint8_t last_iteration_cnt;
+  /// Status Flag indicating for this ULSCH
+  bool active;
+  /// Flag to indicate that the UL configuration has been handled. Used to remove a stale ULSCH when frame wraps around
+  uint8_t handled;
+  NR_ULSCH_delay_t delay;
 } NR_gNB_ULSCH_t;
 
 typedef struct {
@@ -546,15 +557,6 @@ typedef struct {
   /// PRACH background noise level
   int            prach_I0;
 
-  struct delay_s {
-    /// Time shift in number of samples estimated based on DMRS-PUSCH
-    int pusch_est_delay;
-    /// Max position in OFDM symbol related to time shift estimation based on DMRS-PUSCH
-    int pusch_delay_max_pos;
-    /// Max value related to time shift estimation based on DMRS-PUSCH
-    int pusch_delay_max_val;
-  } delay[NUMBER_OF_NR_ULSCH_MAX];
-
 } PHY_MEASUREMENTS_gNB;
 
 
@@ -615,11 +617,7 @@ typedef struct PHY_VARS_gNB_s {
   NR_gNB_PUCCH_t     **pucch;
   NR_gNB_SRS_t       **srs;
   NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_NR_ULSCH_MAX];  // [Nusers times]
-  /// statistics for DLSCH measurement collection
-  NR_gNB_SCH_STATS_t dlsch_stats[NUMBER_OF_NR_SCH_STATS_MAX];
-  /// statistics for ULSCH measurement collection
-  NR_gNB_SCH_STATS_t ulsch_stats[NUMBER_OF_NR_SCH_STATS_MAX];
-  NR_gNB_UCI_STATS_t uci_stats[NUMBER_OF_NR_UCI_STATS_MAX];
+  NR_gNB_PHY_STATS_t phy_stats[MAX_MOBILES_PER_GNB];
   t_nrPolar_params    **polarParams;
 
   /// SRS variables

openair1/SCHED_NR/fapi_nr_l1.c

@@ -103,7 +103,8 @@ void handle_nr_nfapi_ssb_pdu(processingData_L1tx_t *msgTx,int frame,int slot,
 
 void handle_nfapi_nr_csirs_pdu(processingData_L1tx_t *msgTx,
                                int frame,int slot,
-                               nfapi_nr_dl_tti_csi_rs_pdu *csirs_pdu) {
+                               nfapi_nr_dl_tti_csi_rs_pdu *csirs_pdu)
+{
 
   int found = 0;
 
@@ -127,12 +128,12 @@ void handle_nr_nfapi_pdsch_pdu(processingData_L1tx_t *msgTx,
                             uint8_t *sdu)
 {
 
-
   nr_fill_dlsch(msgTx,pdsch_pdu,sdu);
 
 }
 
-void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO){
+void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO)
+{
   
   PHY_VARS_gNB *gNB;
   // copy data from L2 interface into L1 structures
@@ -170,9 +171,9 @@ void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO){
       const time_stats_t ts = exec_time_stats_NotifiedFIFO(res);
       merge_meas(&gNB->phy_proc_tx, &ts);
 
-      msgTx->num_pdsch_slot=0;
-      msgTx->num_dl_pdcch=0;
-      msgTx->num_ul_pdcch=number_ul_dci_pdu;
+      msgTx->num_pdsch_slot = 0;
+      msgTx->num_dl_pdcch = 0;
+      msgTx->num_ul_pdcch = number_ul_dci_pdu;
       msgTx->slot = slot;
       msgTx->frame = frame;
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -1979,13 +1979,9 @@ int get_nrofHARQ_ProcessesForPDSCH(e_NR_PDSCH_ServingCellConfig__nrofHARQ_Proces
   }
 }
 
-/* hack data to remove UE in the phy */
-int rnti_to_remove[10];
-volatile int rnti_to_remove_count;
-pthread_mutex_t rnti_to_remove_mutex = PTHREAD_MUTEX_INITIALIZER;
-
 void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_allocator_t *uia)
 {
+
   NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
   destroy_nr_list(&sched_ctrl->available_dl_harq);
   destroy_nr_list(&sched_ctrl->feedback_dl_harq);
@@ -1997,16 +1993,6 @@ void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_alloca
   LOG_I(NR_MAC, "Remove NR rnti 0x%04x\n", UE->rnti);
   const rnti_t rnti = UE->rnti;
   free(UE);
-  /* hack to remove UE in the phy */
-  if (pthread_mutex_lock(&rnti_to_remove_mutex))
-    exit(1);
-  if (rnti_to_remove_count == 10)
-    exit(1);
-  rnti_to_remove[rnti_to_remove_count] = rnti;
-  LOG_W(NR_MAC, "to remove in mac rnti_to_remove[%d] = 0x%04x\n", rnti_to_remove_count, rnti);
-  rnti_to_remove_count++;
-  if (pthread_mutex_unlock(&rnti_to_remove_mutex))
-    exit(1);
 
   /* clear RA process(es?) associated to the UE */
   for (int cc_id = 0; cc_id < NFAPI_CC_MAX; cc_id++) {
@@ -2015,8 +2001,8 @@ void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_alloca
       if (cc->ra[i].rnti == rnti) {
         LOG_D(NR_MAC, "free RA process %d for rnti %04x\n", i, rnti);
         /* is it enough? */
-        cc->ra[i].cfra  = false;
-        cc->ra[i].rnti  = 0;
+        cc->ra[i].cfra = false;
+        cc->ra[i].rnti = 0;
         cc->ra[i].crnti = 0;
       }
     }
@@ -2524,16 +2510,6 @@ void mac_remove_nr_ue(gNB_MAC_INST *nr_mac, rnti_t rnti)
   delete_nr_ue_data(UE, nr_mac->common_channels, &UE_info->uid_allocator);
 }
 
-void nr_mac_remove_ra_rnti(module_id_t mod_id, rnti_t rnti) {
-  // Hack to remove UE in the phy (following the same procedure as in function mac_remove_nr_ue)
-  if (pthread_mutex_lock(&rnti_to_remove_mutex)) exit(1);
-  if (rnti_to_remove_count == 10) exit(1);
-  rnti_to_remove[rnti_to_remove_count] = rnti;
-  LOG_W(NR_MAC, "to remove in mac rnti_to_remove[%d] = 0x%04x\n", rnti_to_remove_count, rnti);
-  rnti_to_remove_count++;
-  if (pthread_mutex_unlock(&rnti_to_remove_mutex)) exit(1);
-}
-
 uint8_t nr_get_tpc(int target, uint8_t cqi, int incr) {
   // al values passed to this function are x10
   int snrx10 = (cqi*5) - 640;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -680,7 +680,6 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
       
       if(no_sig) {
         LOG_D(NR_MAC, "Random Access %i failed at state %i (no signal)\n", i, ra->state);
-        nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
         nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
       } else {
 
@@ -693,7 +692,6 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
 
           if( (frameP==ra->Msg3_frame) && (slotP==ra->Msg3_slot) ) {
             LOG_D(NR_MAC, "Random Access %i failed at state %i (TC_RNTI %04x RNTI %04x)\n", i, ra->state,ra->rnti,current_rnti);
-            nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
             nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
           }
 
@@ -703,7 +701,6 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
         NR_UE_info_t *UE = add_new_nr_ue(gNB_mac, ra->rnti, ra->CellGroup);
         if (!UE) {
           LOG_W(NR_MAC, "Random Access %i discarded at state %i (TC_RNTI %04x RNTI %04x): max number of users achieved!\n", i, ra->state,ra->rnti,current_rnti);
-          nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
           nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
           return;
         }
@@ -737,7 +734,6 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
 
           LOG_A(NR_MAC, "(rnti 0x%04x) CFRA procedure succeeded!\n", ra->rnti);
           UE->ra_timer = 0;
-          nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
           nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
           process_CellGroup(ra->CellGroup, UE_scheduling_control);
 
@@ -785,7 +781,6 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
             }
           }
           else {
-            nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
             nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
           }
         }
@@ -804,14 +799,12 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
       // for CFRA (NSA) do not schedule retransmission of msg3
       if (ra->cfra) {
         LOG_D(NR_MAC, "Random Access %i failed at state %i (NSA msg3 reception failed)\n", i, ra->state);
-        nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
         nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
         return;
       }
 
       if (ra->msg3_round >= gNB_mac->ul_bler.harq_round_max - 1) {
         LOG_W(NR_MAC, "Random Access %i failed at state %i (Reached msg3 max harq rounds)\n", i, ra->state);
-        nr_mac_remove_ra_rnti(gnb_mod_idP, ra->rnti);
         nr_clear_ra_proc(gnb_mod_idP, CC_idP, frameP, ra);
         return;
       }