merge almost duplicated code for ru prach list and gNB prach list

(gNB is not the proper name, it is CU+DU, gNB is RU+CU+DU)

executables/nr-ru.c

@@ -1208,7 +1208,7 @@ void *ru_thread(void *param)
                      proc->tti_rx * gNB->frame_parms.samples_per_slot_wCP);
 
         // Do PRACH RU processing
-        prach_item_t *p = find_nr_prach_ru(ru, proc->frame_rx, proc->tti_rx, SEARCH_EXIST);
+        prach_item_t *p = find_nr_prach(&ru->prach_list, proc->frame_rx, proc->tti_rx, SEARCH_EXIST);
         if (p) {
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_RU_PRACH_RX, 1 );
 
@@ -1234,7 +1234,7 @@ void *ru_thread(void *param)
                            proc->frame_rx,
                            proc->tti_rx);
           }
-          free_nr_ru_prach_entry(ru, p);
+          free_nr_prach_entry(&ru->prach_list, p);
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_RU_PRACH_RX, 0);
         } // end if (prach_id >= 0)
       } // end if (ru->feprx)

openair1/PHY/INIT/nr_init.c

@@ -192,7 +192,7 @@ void phy_init_nr_gNB(PHY_VARS_gNB *gNB)
   // PRACH
   prach_vars->rxsigF = (int16_t **)malloc16_clear(Prx * sizeof(int16_t *));
 
-  init_prach_list(gNB);
+  init_prach_list(&gNB->prach_vars.list, prach_upper);
 
   int N_RB_UL = cfg->carrier_config.ul_grid_size[cfg->ssb_config.scs_common.value].value;
   int n_buf = Prx*max_ul_mimo_layers;

openair1/PHY/INIT/nr_init_ru.c

@@ -27,8 +27,6 @@
 #include <math.h>
 #include "openair1/PHY/defs_RU.h"
 
-void init_prach_ru_list(RU_t *ru);
-
 void nr_phy_init_RU(RU_t *ru)
 {
   NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
@@ -132,7 +130,7 @@ void nr_phy_init_RU(RU_t *ru)
     LOG_D(PHY, "[INIT] %s() ru->num_gNB:%d \n", __FUNCTION__, ru->num_gNB);
   } // !=IF5
 
-  init_prach_ru_list(ru);
+  init_prach_list(&ru->prach_list, prach_lower);
 }
 
 void nr_phy_free_RU(RU_t *ru)

openair1/PHY/NR_TRANSPORT/nr_prach.c

@@ -36,51 +36,57 @@
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
 #include "openair1/PHY/NR_TRANSPORT/nr_prach.h"
 
-void init_prach_list(PHY_VARS_gNB *gNB)
+void init_prach_list(prach_list_t *l, prach_type_t t)
 {
-  AssertFatal(gNB != NULL, "gNB is null\n");
-  for (int i = 0; i < NUMBER_OF_NR_PRACH_MAX; i++){
-    gNB->prach_vars.list[i].frame = -1;
-    gNB->prach_vars.list[i].slot = -1;
-    gNB->prach_vars.list[i].num_slots = -1;
-  }
+  pthread_mutex_init(&l->prach_list_mutex, NULL);
+  for (prach_item_t *p = l->list; p < l->list + NUMBER_OF_NR_PRACH_MAX; p++)
+    *p = (prach_item_t){.frame = -1, .slot = -1, .type = t};
 }
 
-void free_nr_prach_entry(PHY_VARS_gNB *gNB, prach_item_t *p)
+void free_nr_prach_entry(prach_list_t *l, prach_item_t *p)
 {
-  for (uint16_t i = 0; i < NUMBER_OF_NR_PRACH_MAX; i++) {
-    if (p == gNB->prach_vars.list + i) {
-      p->frame = -1;
-      p->slot = -1;
-      p->num_slots = -1;
-      free_and_zero(p->upper.beam_nb);
-      break;
-    }
-  }
+  pthread_mutex_lock(&l->prach_list_mutex);
+  if (p->type == prach_upper)
+    free_and_zero(p->upper.beam_nb);
+  *p = (prach_item_t){.frame = -1, .slot = -1, .num_slots = -1};
+  pthread_mutex_unlock(&l->prach_list_mutex);
 }
 
-prach_item_t *find_nr_prach(PHY_VARS_gNB *gNB, int frame, int slot, find_type_t type)
+prach_item_t *find_nr_prach(prach_list_t *l, int frame, int slot, find_type_t type)
 {
-  AssertFatal(gNB!=NULL,"gNB is null\n");
-  for (uint16_t i=0; i<NUMBER_OF_NR_PRACH_MAX; i++) {
-    prach_item_t *p = gNB->prach_vars.list + i;
-    LOG_D(PHY, "searching for PRACH in %d.%d prach_index %d=> %d.%d\n", frame, slot, i, p->frame, p->slot);
-    if ((type == SEARCH_EXIST_OR_FREE) && (p->frame == -1) && (p->slot == -1)) {
-      return p;
-    } else if ((type == SEARCH_EXIST) && (p->frame == frame) && (p->slot + p->num_slots - 1 == slot)) {
-      return p;
+  pthread_mutex_lock(&l->prach_list_mutex);
+  prach_item_t *p = l->list;
+  prach_item_t *end = p + NUMBER_OF_NR_PRACH_MAX;
+  for (; p < end; p++)
+    if (p->frame == frame && (p->slot + p->num_slots - 1) == slot)
+      break;
+  if (p == end) {
+    if (type == SEARCH_EXIST) {
+      pthread_mutex_unlock(&l->prach_list_mutex);
+      return NULL;
     }
+    for (p = l->list; p < end; p++)
+      if (p->frame == -1 && p->slot == -1)
+        break;
+  }
+  if (p == end) {
+    pthread_mutex_unlock(&l->prach_list_mutex);
+    return NULL;
   }
-  return NULL;
+  // mark it used, it will be filled later
+  p->frame = frame;
+  pthread_mutex_unlock(&l->prach_list_mutex);
+  return p;
 }
 
 prach_item_t *nr_fill_prach(PHY_VARS_gNB *gNB, int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu)
 {
-  prach_item_t *prach = find_nr_prach(gNB, SFN, Slot, SEARCH_EXIST_OR_FREE);
-  AssertFatal(prach, "prach list full!!!\n");
-  prach->frame = SFN;
-  prach->slot = Slot;
-  prach->type=prach_upper;
+  prach_item_t *prach = find_nr_prach(&gNB->prach_vars.list, SFN, Slot, SEARCH_EXIST_OR_FREE);
+  if (!prach) {
+    LOG_W(PHY, "no free space for a new detected rach, discarding\n");
+    return NULL;
+  }
+  *prach = (prach_item_t){.frame = SFN, .slot = Slot, .type = prach_upper};
   const int format = prach_pdu->prach_format;
   prach->num_slots = (format < 4) ? get_long_prach_dur(format, gNB->frame_parms.numerology_index) : 1;
   if (gNB->common_vars.beam_id) {
@@ -103,66 +109,23 @@ prach_item_t *nr_fill_prach(PHY_VARS_gNB *gNB, int SFN, int Slot, nfapi_nr_prach
   return prach;
 }
 
-void init_prach_ru_list(RU_t *ru)
-{
-  AssertFatal(ru != NULL, "ru is null\n");
-  for (int i = 0; i < NUMBER_OF_NR_PRACH_MAX; i++) {
-    ru->prach_list[i].frame = -1;
-    ru->prach_list[i].slot = -1;
-    ru->prach_list[i].num_slots = -1;
-  }
-  pthread_mutex_init(&ru->prach_list_mutex, NULL);
-}
-
-prach_item_t *find_nr_prach_ru(RU_t *ru, int frame, int slot, find_type_t type)
-{
-  AssertFatal(ru != NULL, "ru is null\n");
-  pthread_mutex_lock(&ru->prach_list_mutex);
-  for (int i = 0; i < NUMBER_OF_NR_PRACH_MAX; i++) {
-    prach_item_t *p = ru->prach_list + i;
-    LOG_D(PHY, "searching for PRACH in %d.%d : prach_index %d=> %d.%d\n", frame, slot, i, p->frame, p->slot);
-    if ((type == SEARCH_EXIST_OR_FREE) && (p->frame == -1) && (p->slot == -1)) {
-      pthread_mutex_unlock(&ru->prach_list_mutex);
-      return p;
-    } else if ((type == SEARCH_EXIST) && (p->frame == frame) && (p->slot + p->num_slots - 1 == slot)) {
-      pthread_mutex_unlock(&ru->prach_list_mutex);
-      return p;
-    }
-  }
-  pthread_mutex_unlock(&ru->prach_list_mutex);
-  return NULL;
-}
-
 void nr_fill_prach_ru(RU_t *ru, int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu, int *beam_id)
 {
-  prach_item_t *prach = find_nr_prach_ru(ru, SFN, Slot, SEARCH_EXIST_OR_FREE);
-  AssertFatal(prach, "ru prach list full\n");
-
-  pthread_mutex_lock(&ru->prach_list_mutex);
-  prach->frame = SFN;
-  prach->slot = Slot;
-  const int fmt = prach_pdu->prach_format;
-  prach->num_slots = (fmt < 4) ? get_long_prach_dur(fmt, ru->nr_frame_parms->numerology_index) : 1;
-  prach->type=prach_lower;
-  prach->lower.fmt = fmt;
-  prach->lower.numRA = prach_pdu->num_ra;
-  prach->lower.beam = beam_id;
-  prach->lower.prachStartSymbol = prach_pdu->prach_start_symbol;
-  prach->lower.num_prach_ocas = prach_pdu->num_prach_ocas;
-  pthread_mutex_unlock(&ru->prach_list_mutex);
-}
-
-void free_nr_ru_prach_entry(RU_t *ru, prach_item_t *p)
-{
-  pthread_mutex_lock(&ru->prach_list_mutex);
-  for (int i = 0; i < NUMBER_OF_NR_PRACH_MAX; i++) {
-    if (p == ru->prach_list + i) {
-      p->frame = -1;
-      p->slot = -1;
-      break;
-    }
+  prach_item_t *prach = find_nr_prach(&ru->prach_list, SFN, Slot, SEARCH_EXIST_OR_FREE);
+  if (!prach) {
+    LOG_E(PHY, "no prach memory found\n");
+    return;
   }
-  pthread_mutex_unlock(&ru->prach_list_mutex);
+  const int fmt = prach_pdu->prach_format;
+  *prach = (prach_item_t){.frame = SFN,
+                          .slot = Slot,
+                          .type = prach_lower,
+                          .num_slots = (fmt < 4) ? get_long_prach_dur(fmt, ru->nr_frame_parms->numerology_index) : 1,
+                          .lower = {.fmt = fmt,
+                                    .numRA = prach_pdu->num_ra,
+                                    .beam = beam_id,
+                                    .prachStartSymbol = prach_pdu->prach_start_symbol,
+                                    .num_prach_ocas = prach_pdu->num_prach_ocas}};
 }
 
 void rx_nr_prach_ru(RU_t *ru,

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -222,10 +222,7 @@ void rx_nr_prach_ru(RU_t *ru,
                     int subframe);
 
 void nr_fill_prach_ru(RU_t *ru,int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu, int *beam_nb);
-
-prach_item_t *find_nr_prach(PHY_VARS_gNB *gNB, int frame, int slot, find_type_t type);
-prach_item_t *find_nr_prach_ru(RU_t *ru, int frame, int slot, find_type_t type);
-
+prach_item_t *find_nr_prach(prach_list_t *, int frame, int slot, find_type_t type);
 void nr_fill_pucch(PHY_VARS_gNB *gNB,
                    int frame,
                    int slot,
@@ -245,12 +242,9 @@ int nr_get_srs_signal(PHY_VARS_gNB *gNB,
                       c16_t srs_received_signal[][gNB->frame_parms.ofdm_symbol_size * (1 << srs_pdu->num_symbols)],
                       c16_t srs_received_noise[][gNB->frame_parms.ofdm_symbol_size * (1 << srs_pdu->num_symbols)]);
 
-void init_prach_list(PHY_VARS_gNB *gNB);
-void init_prach_ru_list(RU_t *ru);
-void free_nr_ru_prach_entry(RU_t *ru, prach_item_t *p);
 int get_nr_prach_duration(uint8_t prach_format);
 
-void free_nr_prach_entry(PHY_VARS_gNB *gNB, prach_item_t *);
+void free_nr_prach_entry(prach_list_t *, prach_item_t *);
 
 void nr_decode_pucch1(c16_t **rxdataF,
                       pucch_GroupHopping_t pucch_GroupHopping,

openair1/PHY/defs_RU.h

@@ -592,10 +592,7 @@ typedef struct RU_t_s {
   int32_t *bw_list[NUMBER_OF_eNB_MAX+1];
   /// beamforming weight vectors
   int32_t **beam_weights[NUMBER_OF_eNB_MAX+1][15];
-  /// prach commands
-  prach_item_t prach_list[NUMBER_OF_NR_PRACH_MAX];
-  /// mutex for prach_list access
-  pthread_mutex_t prach_list_mutex;
+  prach_list_t prach_list;
   /// received frequency-domain signal for PRACH (IF4p5 RRU) 
   int16_t **prach_rxsigF[NUMBER_OF_NR_RU_PRACH_OCCASIONS_MAX];
   /// received frequency-domain signal for PRACH BR (IF4p5 RRU)

openair1/PHY/defs_common.h

@@ -1001,11 +1001,12 @@ typedef struct {
 // TODO will be removed in a late commit
 #include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface_scf.h"
 #define NUMBER_OF_NR_PRACH_MAX 8
+typedef enum { prach_upper, prach_lower } prach_type_t;
 typedef struct {
   int frame;
   int slot;
   int num_slots; // prach duration in slots
-  enum { prach_upper, prach_lower } type;
+  prach_type_t type;
   union {
     struct {
       // identifier for concurrent beams
@@ -1023,6 +1024,14 @@ typedef struct {
   nfapi_nr_prach_pdu_t pdu;
 } prach_item_t;
 
+typedef struct {
+  /// prach commands
+  prach_item_t list[NUMBER_OF_NR_PRACH_MAX];
+  /// mutex for prach_list access
+  pthread_mutex_t prach_list_mutex;
+} prach_list_t;
+void init_prach_list(prach_list_t *, prach_type_t);
+
 static inline void init_abort(decode_abort_t *ab)
 {
   int ret = pthread_mutex_init(&ab->mutex_failure, NULL);

openair1/PHY/defs_gNB.h

@@ -139,7 +139,7 @@ typedef struct {
   /// second index: rx antenna [0..63] (hard coded) \note Hard coded array size indexed by \c nb_antennas_rx.
   /// third index: frequency-domain sample [0..ofdm_symbol_size*12[
   int16_t **rxsigF;
-  prach_item_t list[NUMBER_OF_NR_PRACH_MAX];
+  prach_list_t list;
 } NR_gNB_PRACH;
 
 typedef struct {

openair1/SCHED/nfapi_nr_dummy.c

@@ -37,10 +37,7 @@ void nr_fill_pucch(PHY_VARS_gNB *gNB,
                    int frame,
                    int slot,
                    nfapi_nr_pucch_pdu_t *pucch_pdu){}
-gNB_PRACH_list_t nr_fill_prach(PHY_VARS_gNB *gNB, int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu)
-{
-}
-RU_PRACH_list_t nr_fill_prach_ru(RU_t *ru, int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu)
+void nr_fill_prach(PHY_VARS_gNB *gNB, int SFN, int Slot, nfapi_nr_prach_pdu_t *prach_pdu)
 {
 }
 

openair1/SCHED_NR/nr_prach_procedures.c

@@ -63,7 +63,7 @@ void L1_nr_prach_procedures(PHY_VARS_gNB *gNB, int frame, int slot, nfapi_nr_rac
 
   ru=gNB->RU_list[0];
 
-  prach_item_t *prach_id = find_nr_prach(gNB, frame, slot, SEARCH_EXIST);
+  prach_item_t *prach_id = find_nr_prach(&gNB->prach_vars.list, frame, slot, SEARCH_EXIST);
   if (!prach_id) {
     return;
   }
@@ -145,6 +145,6 @@ void L1_nr_prach_procedures(PHY_VARS_gNB *gNB, int frame, int slot, nfapi_nr_rac
   } // if prach_id>0
   rach_ind->slot = prach_start_slot;
   LOG_D(NR_PHY, "Freeing PRACH entry\n");
-  free_nr_prach_entry(gNB, prach_id);
+  free_nr_prach_entry(&gNB->prach_vars.list, prach_id);
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PRACH_RX,0);
 }

openair1/SIMULATION/NR_PHY/prachsim.c

@@ -151,9 +151,7 @@ int main(int argc, char **argv){
 
   NR_DL_FRAME_PARMS *frame_parms;
   nfapi_nr_prach_config_t *prach_config;
-  nfapi_nr_prach_pdu_t *prach_pdu;
   fapi_nr_prach_config_t *ue_prach_config;
-  fapi_nr_ul_config_prach_pdu *ue_prach_pdu;
 
   channel_desc_t *UE2gNB;
   SCM_t channel_model = Rayleigh1;
@@ -417,7 +415,6 @@ int main(int argc, char **argv){
   ru           = RC.ru[0];
   frame_parms  = &gNB->frame_parms;
   prach_config = &gNB->gNB_config.prach_config;
-  prach_pdu    = &gNB->prach_vars.list[0].pdu;
   frame_parms  = &gNB->frame_parms; //to be initialized I suppose (maybe not necessary for PBCH)
 
   s_re = malloc(2*sizeof(double*));
@@ -561,9 +558,6 @@ int main(int argc, char **argv){
   prach_config->restricted_set_config.value                                              = restrictedSetConfig;
   prach_config->prach_sequence_length.value                                              = prach_sequence_length;
   prach_config->prach_sub_c_spacing.value                                                = mu;
-  prach_pdu->num_cs                                                                      = get_NCS(NCS_config, format0, restrictedSetConfig);
-  prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value        = 1+(64/(N_ZC/prach_pdu->num_cs));
-  prach_pdu->prach_format                                                                = prach_format;
 
   memcpy((void*)&ru->config,(void*)&RC.gNB[0]->gNB_config,sizeof(ru->config));
   RC.nb_nr_L1_inst=1;
@@ -573,6 +567,10 @@ int main(int argc, char **argv){
 
   phy_init_nr_gNB(gNB);
   nr_phy_init_RU(ru);
+  nfapi_nr_prach_pdu_t *prach_pdu = &gNB->prach_vars.list.list[0].pdu;
+  prach_pdu->num_cs                                                                      = get_NCS(NCS_config, format0, restrictedSetConfig);
+  prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value        = 1+(64/(N_ZC/prach_pdu->num_cs));
+  prach_pdu->prach_format                                                                = prach_format;
 
   // Configure UE
   UE = malloc(sizeof(PHY_VARS_NR_UE));
@@ -588,7 +586,7 @@ int main(int argc, char **argv){
     exit(-1);
   }
 
-  ue_prach_pdu           = &UE->prach_vars[0]->prach_pdu;
+  fapi_nr_ul_config_prach_pdu *ue_prach_pdu = &UE->prach_vars[0]->prach_pdu;
   ue_prach_config        = &UE->nrUE_config.prach_config;
   txdata = UE->common_vars.txData;