Merge remote-tracking branch 'origin/develop' into bupt-ulmimo-4

executables/nr-gnb.c

@@ -87,7 +87,6 @@
 #include <openair1/PHY/NR_TRANSPORT/nr_ulsch.h>
 #include <openair1/PHY/NR_TRANSPORT/nr_dlsch.h>
 #include <PHY/NR_ESTIMATION/nr_ul_estimation.h>
-//#define DEBUG_THREADS 1
 
 //#define USRP_DEBUG 1
 // Fix per CC openair rf/if device update
@@ -114,7 +113,6 @@ time_stats_t softmodem_stats_rx_sf; // total rx time
 void tx_func(void *param) {
 
   processingData_L1tx_t *info = (processingData_L1tx_t *) param;
-  PHY_VARS_gNB *gNB = info->gNB;
   int frame_tx = info->frame;
   int slot_tx = info->slot;
 
@@ -122,35 +120,9 @@ void tx_func(void *param) {
                         frame_tx,
                         slot_tx,
                         1);
-  info->slot = -1;
-  //if ((frame_tx&127) == 0) dump_pdsch_stats(fd,gNB);
-
-  // If the later of the 2 L1 tx thread finishes first,
-  // we wait for the earlier one to finish and start the RU thread
-  // to avoid realtime issues with USRP
-
-  // Start RU TX processing.
-  notifiedFIFO_elt_t *res;
-  res = pullTpool(gNB->resp_RU_tx, gNB->threadPool);
-  processingData_RU_t *syncMsg = (processingData_RU_t *)NotifiedFifoData(res);
-  LOG_D(PHY,"waiting for previous tx to finish, next slot %d,%d\n",syncMsg->next_slot,slot_tx);
-  while (syncMsg->next_slot != slot_tx) {
-    pushNotifiedFIFO(gNB->resp_RU_tx, res);
-    res = pullTpool(gNB->resp_RU_tx, gNB->threadPool);
-    syncMsg = (processingData_RU_t *)NotifiedFifoData(res);
-  }
-  LOG_D(PHY,"previous tx finished, next slot %d,%d\n",syncMsg->next_slot,slot_tx);
-  syncMsg->frame_tx = frame_tx;
-  syncMsg->slot_tx = slot_tx;
-  syncMsg->next_slot = get_next_downlink_slot(gNB, &gNB->gNB_config, frame_tx, slot_tx);
-  syncMsg->timestamp_tx = info->timestamp_tx;
-  syncMsg->ru = gNB->RU_list[0];
-  res->key = slot_tx;
-  pushTpool(gNB->threadPool, res);
 }
 
 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;
@@ -275,15 +247,12 @@ void rx_func(void *param) {
   
   if (tx_slot_type == NR_DOWNLINK_SLOT || tx_slot_type == NR_MIXED_SLOT) {
     notifiedFIFO_elt_t *res;
-    res = pullTpool(gNB->resp_L1_tx, gNB->threadPool);
-    processingData_L1tx_t *syncMsg = (processingData_L1tx_t *)NotifiedFifoData(res);
-    while (syncMsg->slot != slot_tx) {
-      pushNotifiedFIFO(gNB->resp_L1_tx, res);
-      res = pullTpool(gNB->resp_L1_tx, gNB->threadPool);
-      syncMsg = (processingData_L1tx_t *)NotifiedFifoData(res);
-    }
+    processingData_L1tx_t *syncMsg;
+    // Its a FIFO so it maitains the order in which the MAC fills the messages
+    // so no need for checking for right slot
+    res = pullTpool(gNB->L1_tx_filled, gNB->threadPool);
+    syncMsg = (processingData_L1tx_t *)NotifiedFifoData(res);
     syncMsg->gNB = gNB;
-    AssertFatal(syncMsg->slot == slot_tx, "Thread message slot and logical slot number do not match\n");
     syncMsg->timestamp_tx = info->timestamp_tx;
     res->key = slot_tx;
     pushTpool(gNB->threadPool, res);
@@ -331,13 +300,14 @@ void rx_func(void *param) {
 }
 static void dump_L1_meas_stats(PHY_VARS_gNB *gNB, RU_t *ru, char *output) {
   int stroff = 0;
-  stroff += print_meas_log(gNB->phy_proc_tx_0, "L1 Tx processing thread 0", NULL, NULL, output);
-  stroff += print_meas_log(gNB->phy_proc_tx_1, "L1 Tx processing thread 1", NULL, NULL, output+stroff);
+  stroff += print_meas_log(gNB->phy_proc_tx[0], "L1 Tx processing thread 0", NULL, NULL, output);
+  //stroff += print_meas_log(gNB->phy_proc_tx[1], "L1 Tx processing thread 1", NULL, NULL, output+stroff);
   stroff += print_meas_log(&gNB->dlsch_encoding_stats, "DLSCH encoding", NULL, NULL, output+stroff);
   stroff += print_meas_log(&gNB->phy_proc_rx, "L1 Rx processing", NULL, NULL, output+stroff);
   stroff += print_meas_log(&gNB->ul_indication_stats, "UL Indication", NULL, NULL, output+stroff);
   stroff += print_meas_log(&gNB->rx_pusch_stats, "PUSCH inner-receiver", NULL, NULL, output+stroff);
   stroff += print_meas_log(&gNB->ulsch_decoding_stats, "PUSCH decoding", NULL, NULL, output+stroff);
+  stroff += print_meas_log(&gNB->schedule_response_stats, "Schedule Response",NULL,NULL, output+stroff);
   if (ru->feprx) stroff += print_meas_log(&ru->ofdm_demod_stats,"feprx",NULL,NULL, output+stroff);
 
   if (ru->feptx_ofdm) {
@@ -367,13 +337,14 @@ void *nrL1_stats_thread(void *param) {
   fd=fopen("nrL1_stats.log","w");
   AssertFatal(fd!=NULL,"Cannot open nrL1_stats.log\n");
 
-  reset_meas(gNB->phy_proc_tx_0);
-  reset_meas(gNB->phy_proc_tx_1);
+  reset_meas(gNB->phy_proc_tx[0]);
+  //reset_meas(gNB->phy_proc_tx[1]);
   reset_meas(&gNB->dlsch_encoding_stats);
   reset_meas(&gNB->phy_proc_rx);
   reset_meas(&gNB->ul_indication_stats);
   reset_meas(&gNB->rx_pusch_stats);
   reset_meas(&gNB->ulsch_decoding_stats);
+  reset_meas(&gNB->schedule_response_stats);
 
   while (!oai_exit) {
     sleep(1);
@@ -389,6 +360,52 @@ void *nrL1_stats_thread(void *param) {
   return(NULL);
 }
 
+// This thread reads the finished L1 tx jobs from threaPool
+// and pushes RU tx thread in the right order. It works only
+// two parallel L1 tx threads.
+void *tx_reorder_thread(void* param) {
+  PHY_VARS_gNB *gNB = (PHY_VARS_gNB *)param;
+    notifiedFIFO_elt_t *resL1Reserve = NULL;
+  
+
+  resL1Reserve=pullTpool(gNB->L1_tx_out, gNB->threadPool);
+  int next_tx_slot=((processingData_L1tx_t *)NotifiedFifoData(resL1Reserve))->slot;
+  
+  while (!oai_exit) {
+    notifiedFIFO_elt_t *resL1;
+    if (resL1Reserve) {
+       resL1=resL1Reserve;
+       if (((processingData_L1tx_t *)NotifiedFifoData(resL1))->slot != next_tx_slot) {
+         LOG_E(PHY,"order mistake");
+	 resL1Reserve=NULL;
+	 resL1 = pullTpool(gNB->L1_tx_out, gNB->threadPool);
+       }
+     } else { 
+       resL1 = pullTpool(gNB->L1_tx_out, gNB->threadPool);
+       if (((processingData_L1tx_t *)NotifiedFifoData(resL1))->slot != next_tx_slot) {
+          if (resL1Reserve)
+              LOG_E(PHY,"error, have a stored packet, then a second one\n");
+	  resL1Reserve=resL1;
+          resL1 = pullTpool(gNB->L1_tx_out, gNB->threadPool);
+          if (((processingData_L1tx_t *)NotifiedFifoData(resL1))->slot != next_tx_slot)
+	    LOG_E(PHY,"error, pull two msg, none is good\n");
+       }
+    }
+    processingData_L1tx_t *syncMsgL1= (processingData_L1tx_t *)NotifiedFifoData(resL1);
+    processingData_RU_t syncMsgRU;
+    syncMsgRU.frame_tx = syncMsgL1->frame;
+    syncMsgRU.slot_tx = syncMsgL1->slot;
+    syncMsgRU.timestamp_tx = syncMsgL1->timestamp_tx;
+    syncMsgRU.ru = gNB->RU_list[0];
+    next_tx_slot = get_next_downlink_slot(gNB, &gNB->gNB_config, syncMsgRU.frame_tx, syncMsgRU.slot_tx);
+    pushNotifiedFIFO(gNB->L1_tx_free, resL1);
+    if (resL1==resL1Reserve)
+       resL1Reserve=NULL;
+    ru_tx_func((void*)&syncMsgRU);
+  }
+  return(NULL);
+}
+
 void init_gNB_Tpool(int inst) {
   PHY_VARS_gNB *gNB;
   gNB = RC.gNB[inst];
@@ -397,8 +414,8 @@ void init_gNB_Tpool(int inst) {
   // ULSCH decoding threadpool
   gNB->threadPool = (tpool_t*)malloc(sizeof(tpool_t));
   int numCPU = sysconf(_SC_NPROCESSORS_ONLN);
-  LOG_I(PHY,"Number of threads requested in config file: %d, Number of threads available on this machine: %d\n",gNB->pusch_proc_threads,numCPU);
-  int threadCnt = min(numCPU, gNB->pusch_proc_threads);
+  LOG_I(PHY,"Number of threads requested in config file: %d, Number of threads available on this machine: %d\n",gNB->thread_pool_size,numCPU);
+  int threadCnt = min(numCPU, gNB->thread_pool_size);
   if (threadCnt < 2) LOG_E(PHY,"Number of threads for gNB should be more than 1. Allocated only %d\n",threadCnt);
   char pool[80];
   sprintf(pool,"-1");
@@ -420,40 +437,29 @@ void init_gNB_Tpool(int inst) {
   pushNotifiedFIFO(gNB->resp_L1,msg); // to unblock the process in the beginning
 
   // L1 TX result FIFO 
-  gNB->resp_L1_tx = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
-  initNotifiedFIFO(gNB->resp_L1_tx);
+  gNB->L1_tx_free = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
+  gNB->L1_tx_filled = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
+  gNB->L1_tx_out = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
+  initNotifiedFIFO(gNB->L1_tx_free);
+  initNotifiedFIFO(gNB->L1_tx_filled);
+  initNotifiedFIFO(gNB->L1_tx_out);
+  
   // we create 2 threads for L1 tx processing
-  notifiedFIFO_elt_t *msgL1Tx = newNotifiedFIFO_elt(sizeof(processingData_L1tx_t),0,gNB->resp_L1_tx,tx_func);
-  processingData_L1tx_t *msgDataTx = (processingData_L1tx_t *)NotifiedFifoData(msgL1Tx);
-  init_DLSCH_struct(gNB, msgDataTx);
-  msgDataTx->slot = -1;
-  memset(msgDataTx->ssb, 0, 64*sizeof(NR_gNB_SSB_t));
-  reset_meas(&msgDataTx->phy_proc_tx);
-  gNB->phy_proc_tx_0 = &msgDataTx->phy_proc_tx;
-  pushNotifiedFIFO(gNB->resp_L1_tx,msgL1Tx); // to unblock the process in the beginning
-
-  msgL1Tx = newNotifiedFIFO_elt(sizeof(processingData_L1tx_t),0,gNB->resp_L1_tx,tx_func);
-  msgDataTx = (processingData_L1tx_t *)NotifiedFifoData(msgL1Tx);
-  init_DLSCH_struct(gNB, msgDataTx);
-  msgDataTx->slot = -1;
-  memset(msgDataTx->ssb, 0, 64*sizeof(NR_gNB_SSB_t));
-  reset_meas(&msgDataTx->phy_proc_tx);
-  gNB->phy_proc_tx_1 = &msgDataTx->phy_proc_tx;
-  pushNotifiedFIFO(gNB->resp_L1_tx,msgL1Tx); // to unblock the process in the beginning
-
-  // RU TX result FIFO 
-  gNB->resp_RU_tx = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
-  initNotifiedFIFO(gNB->resp_RU_tx);
-  notifiedFIFO_elt_t *msgRUTx = newNotifiedFIFO_elt(sizeof(processingData_RU_t),0,gNB->resp_RU_tx,ru_tx_func);
-  processingData_RU_t *msgData = (processingData_RU_t*)msgRUTx->msgData;
-  int first_tx_slot = sf_ahead*gNB->frame_parms.slots_per_subframe;
-  msgData->next_slot = get_next_downlink_slot(gNB, &gNB->gNB_config, 0, first_tx_slot-1);
-  pushNotifiedFIFO(gNB->resp_RU_tx,msgRUTx); // to unblock the process in the beginning
-
-  if (!get_softmodem_params()->emulate_l1) {
-    threadCreate(&proc->L1_stats_thread,nrL1_stats_thread,(void*)gNB,"L1_stats",-1,OAI_PRIORITY_RT_LOW);
+  for (int i=0; i < 2; i++) {
+    notifiedFIFO_elt_t *msgL1Tx = newNotifiedFIFO_elt(sizeof(processingData_L1tx_t),0,gNB->L1_tx_out,tx_func);
+    processingData_L1tx_t *msgDataTx = (processingData_L1tx_t *)NotifiedFifoData(msgL1Tx);
+    init_DLSCH_struct(gNB, msgDataTx);
+    memset(msgDataTx->ssb, 0, 64*sizeof(NR_gNB_SSB_t));
+    reset_meas(&msgDataTx->phy_proc_tx);
+    gNB->phy_proc_tx[i] = &msgDataTx->phy_proc_tx;
+    pushNotifiedFIFO(gNB->L1_tx_free,msgL1Tx); // to unblock the process in the beginning
   }
 
+  if (!get_softmodem_params()->emulate_l1) 
+     threadCreate(&proc->L1_stats_thread,nrL1_stats_thread,(void*)gNB,"L1_stats",-1,OAI_PRIORITY_RT_LOW);
+
+  threadCreate(&proc->pthread_tx_reorder, tx_reorder_thread, (void *)gNB, "thread_tx_reorder", -1, OAI_PRIORITY_RT_MAX);
+
 }
 
 

executables/nr-ru.c

@@ -1471,11 +1471,9 @@ void *ru_thread( void *param ) {
 
   res = pullNotifiedFIFO(gNB->resp_L1);
   delNotifiedFIFO_elt(res);
-  res = pullNotifiedFIFO(gNB->resp_L1_tx);
+  res = pullNotifiedFIFO(gNB->L1_tx_free);
   delNotifiedFIFO_elt(res);
-  res = pullNotifiedFIFO(gNB->resp_L1_tx);
-  delNotifiedFIFO_elt(res);
-  res = pullNotifiedFIFO(gNB->resp_RU_tx);
+  res = pullNotifiedFIFO(gNB->L1_tx_free);
   delNotifiedFIFO_elt(res);
 
   ru_thread_status = 0;

executables/nr-softmodem-common.h

@@ -88,8 +88,9 @@
 #define CONFIG_HLP_NOTWAIT       "don't wait for tracer, start immediately\n"
 #define CONFIG_HLP_TNOFORK       "to ease debugging with gdb\n"
 #define CONFIG_HLP_DISABLNBIOT   "disable nb-iot, even if defined in config\n"
-#define CONFIG_HLP_DISABLETIMECORR   "disable UE timing correction\n"
-#define CONFIG_HLP_RRC_CFG_PATH   "path for RRC configuration\n"
+#define CONFIG_HLP_DISABLETIMECORR "disable UE timing correction\n"
+#define CONFIG_HLP_RRC_CFG_PATH  "path for RRC configuration\n"
+#define CONFIG_HLP_UECAP_FILE    "path for UE Capabilities file\n"
 
 #define CONFIG_HLP_NUMEROLOGY    "adding numerology for 5G\n"
 #define CONFIG_HLP_EMULATE_RF    "Emulated RF enabled(disable by defult)\n"

executables/nr-softmodem.c

@@ -111,16 +111,11 @@ int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
 
 //Temp fix for inexistent NR upper layer
 unsigned char NB_gNB_INST = 1;
+char *uecap_file;
 
-
-int UE_scan = 1;
-int UE_scan_carrier = 0;
 runmode_t mode = normal_txrx;
 static double snr_dB=20;
 
-FILE *input_fd=NULL;
-
-
 #if MAX_NUM_CCs == 1
 rx_gain_t rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain}};
 double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0}};
@@ -193,8 +188,6 @@ openair0_config_t openair0_cfg[MAX_CARDS];
 
 double cpuf;
 
-extern char uecap_xer[1024];
-char uecap_xer_in=0;
 
 /* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
  * this is very hackish - find a proper solution
@@ -710,6 +703,7 @@ int main( int argc, char **argv ) {
   // don't create if node doesn't connect to RRC/S1/GTP
   int ret=create_gNB_tasks(1);
   AssertFatal(ret==0,"cannot create ITTI tasks\n");
+
   /* Start the agent. If it is turned off in the configuration, it won't start */
   /*
   RCconfig_nr_flexran();

executables/nr-softmodem.h

@@ -30,6 +30,7 @@
     {"D" ,                    CONFIG_HLP_DLBM_PHYTEST,0,                u64ptr:&dlsch_slot_bitmap,          defintval:0,                   TYPE_UINT64, 0},        \
     {"U" ,                    CONFIG_HLP_ULBM_PHYTEST,0,                u64ptr:&ulsch_slot_bitmap,          defintval:0,                   TYPE_UINT64, 0},        \
     {"usrp-tx-thread-config", CONFIG_HLP_USRP_THREAD, 0,                iptr:&usrp_tx_thread,               defstrval:0,                   TYPE_INT,    0},        \
+    {"uecap_file",            CONFIG_HLP_UECAP_FILE,  0,                strptr:(char **)&uecap_file,        defstrval:"./uecap.xml",       TYPE_STRING, 0},        \
     {"s" ,                    CONFIG_HLP_SNR,         0,                dblptr:&snr_dB,                     defdblval:25,                  TYPE_DOUBLE, 0},        \
   }
 
@@ -43,6 +44,7 @@ extern uint32_t target_dl_bw;
 extern uint32_t target_ul_bw;
 extern uint64_t dlsch_slot_bitmap;
 extern uint64_t ulsch_slot_bitmap;
+extern char *uecap_file;
 
 // In nr-gnb.c
 extern void init_gNB(int single_thread_flag,int wait_for_sync);

executables/nr-ue.c

@@ -106,6 +106,49 @@ queue_t nr_rach_ind_queue;
 
 static void *NRUE_phy_stub_standalone_pnf_task(void *arg);
 
+static int dump_L1_UE_meas_stats(PHY_VARS_NR_UE *ue, char *output, int max_len)
+{
+  int stroff = 0;
+  stroff += print_meas_log(&ue->phy_proc_tx, "L1 TX processing", NULL, NULL, output);
+  stroff += print_meas_log(&ue->ulsch_encoding_stats, "ULSCH encoding", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->phy_proc_rx[0], "L1 RX processing t0", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->phy_proc_rx[1], "L1 RX processing t1", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->ue_ul_indication_stats, "UL Indication", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->rx_pdsch_stats, "PDSCH receiver", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_decoding_stats[0], "PDSCH decoding t0", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_decoding_stats[1], "PDSCH decoding t1", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_deinterleaving_stats, " -> Deinterleive", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_rate_unmatching_stats, " -> Rate Unmatch", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_ldpc_decoding_stats, " ->  LDPC Decode", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_unscrambling_stats, "PDSCH unscrambling", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_rx_pdcch_stats, "PDCCH handling", NULL, NULL, output + stroff);
+  return stroff;
+}
+
+static void *nrL1_UE_stats_thread(void *param)
+{
+  PHY_VARS_NR_UE *ue = (PHY_VARS_NR_UE *) param;
+  const int max_len = 16384;
+  char output[max_len];
+  char filename[30];
+  snprintf(filename, 29, "nrL1_UE_stats-%d.log", ue->Mod_id);
+  filename[29] = 0;
+  FILE *fd = fopen(filename, "w");
+  AssertFatal(fd != NULL, "Cannot open %s\n", filename);
+
+  while (!oai_exit) {
+    sleep(1);
+    const int len = dump_L1_UE_meas_stats(ue, output, max_len);
+    AssertFatal(len < max_len, "exceeded length\n");
+    fwrite(output, len + 1, 1, fd); // + 1 for terminating NULL byte
+    fflush(fd);
+    fseek(fd, 0, SEEK_SET);
+  }
+  fclose(fd);
+
+  return NULL;
+}
+
 void init_nr_ue_vars(PHY_VARS_NR_UE *ue,
                      uint8_t UE_id,
                      uint8_t abstraction_flag)
@@ -595,7 +638,7 @@ static void UE_synch(void *arg) {
       uint64_t dl_carrier, ul_carrier;
       nr_get_carrier_frequencies(UE, &dl_carrier, &ul_carrier);
 
-      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa, get_nrUE_params()->nr_dlsch_parallel) == 0) {
+      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa) == 0) {
         freq_offset = UE->common_vars.freq_offset; // frequency offset computed with pss in initial sync
         hw_slot_offset = ((UE->rx_offset<<1) / UE->frame_parms.samples_per_subframe * UE->frame_parms.slots_per_subframe) +
                          round((float)((UE->rx_offset<<1) % UE->frame_parms.samples_per_subframe)/UE->frame_parms.samples_per_slot0);
@@ -668,6 +711,7 @@ void processSlotTX(void *arg) {
     // trigger L2 to run ue_scheduler thru IF module
     // [TODO] mapping right after NR initial sync
     if(UE->if_inst != NULL && UE->if_inst->ul_indication != NULL) {
+      start_meas(&UE->ue_ul_indication_stats);
       nr_uplink_indication_t ul_indication;
       memset((void*)&ul_indication, 0, sizeof(ul_indication));
 
@@ -682,6 +726,7 @@ void processSlotTX(void *arg) {
       ul_indication.ue_sched_mode = rxtxD->ue_sched_mode;
 
       UE->if_inst->ul_indication(&ul_indication);
+      stop_meas(&UE->ue_ul_indication_stats);
     }
 
     if ((UE->mode != loop_through_memory) && (rxtxD->ue_sched_mode != NOT_PUSCH)) {
@@ -1143,13 +1188,15 @@ void *UE_thread(void *arg) {
   return NULL;
 }
 
-void init_NR_UE(int nb_inst, char* rrc_config_path) {
+void init_NR_UE(int nb_inst,
+                char* uecap_file,
+                char* rrc_config_path) {
   int inst;
   NR_UE_MAC_INST_t *mac_inst;
   NR_UE_RRC_INST_t* rrc_inst;
   
   for (inst=0; inst < nb_inst; inst++) {
-    AssertFatal((rrc_inst = nr_l3_init_ue(rrc_config_path)) != NULL, "can not initialize RRC module\n");
+    AssertFatal((rrc_inst = nr_l3_init_ue(uecap_file,rrc_config_path)) != NULL, "can not initialize RRC module\n");
     AssertFatal((mac_inst = nr_l2_init_ue(rrc_inst)) != NULL, "can not initialize L2 module\n");
     AssertFatal((mac_inst->if_module = nr_ue_if_module_init(inst)) != NULL, "can not initialize IF module\n");
   }
@@ -1165,6 +1212,8 @@ void init_NR_UE_threads(int nb_inst) {
 
     LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
     threadCreate(&threads[inst], UE_thread, (void *)UE, "UEthread", -1, OAI_PRIORITY_RT_MAX);
+    pthread_t stat_pthread;
+    threadCreate(&stat_pthread, nrL1_UE_stats_thread, UE, "L1_UE_stats", -1, OAI_PRIORITY_RT_LOW);
   }
 }
 

executables/nr-uesoftmodem.c

@@ -118,6 +118,7 @@ int                 vcdflag = 0;
 double          rx_gain_off = 0.0;
 char             *usrp_args = NULL;
 char       *rrc_config_path = NULL;
+char            *uecap_file = NULL;
 int               dumpframe = 0;
 
 uint64_t        downlink_frequency[MAX_NUM_CCs][4];
@@ -150,8 +151,6 @@ int            numerology = 0;
 int           oaisim_flag = 0;
 int            emulate_rf = 0;
 uint32_t       N_RB_DL    = 106;
-char         uecap_xer_in = 0;
-char         uecap_xer[1024];
 
 /* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
  * this is very hackish - find a proper solution
@@ -264,14 +263,6 @@ static void get_options(void) {
 
   if (vcdflag > 0)
     ouput_vcd = 1;
-
-  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT))  && (!(CONFIG_ISFLAGSET(CONFIG_NOOOPT))) ) {
-    // Here the configuration file is the XER encoded UE capabilities
-    // Read it in and store in asn1c data structures
-    sprintf(uecap_xer,"%stargets/PROJECTS/GENERIC-LTE-EPC/CONF/UE_config.xml",getenv("OPENAIR_HOME"));
-    printf("%s\n",uecap_xer);
-    uecap_xer_in=1;
-  } /* UE with config file  */
 }
 
 // set PHY vars from command line
@@ -431,11 +422,11 @@ int main( int argc, char **argv ) {
   get_options (); //Command-line options specific for NRUE
 
   get_common_options(SOFTMODEM_5GUE_BIT);
-  init_tpools(nrUE_params.nr_dlsch_parallel);
   CONFIG_CLEARRTFLAG(CONFIG_NOEXITONHELP);
 #if T_TRACER
   T_Config_Init();
 #endif
+  init_tpools(nrUE_params.nr_dlsch_parallel);
   //randominit (0);
   set_taus_seed (0);
 
@@ -454,7 +445,7 @@ int main( int argc, char **argv ) {
 #endif
   LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);
 
-  init_NR_UE(1,rrc_config_path);
+  init_NR_UE(1,uecap_file,rrc_config_path);
 
   int mode_offset = get_softmodem_params()->nsa ? NUMBER_OF_UE_MAX : 1;
   uint16_t node_number = get_softmodem_params()->node_number;

executables/nr-uesoftmodem.h

@@ -33,8 +33,9 @@
     {"dlsch-parallel",           CONFIG_HLP_DLSCH_PARA,  0,               iptr:(int32_t *)&nrUE_params.nr_dlsch_parallel,       defintval:0,           TYPE_UINT8,  0}, \
     {"offset-divisor",           CONFIG_HLP_OFFSET_DIV,  0,               uptr:(uint32_t *)&nrUE_params.ofdm_offset_divisor,    defuintval:UINT_MAX,           TYPE_UINT32,  0}, \
     {"nr-dlsch-demod-shift",     CONFIG_HLP_DLSHIFT,     0,               iptr:(int32_t *)&nr_dlsch_demod_shift,    defintval:0,     TYPE_INT,    0}, \
-    {"V" ,                       CONFIG_HLP_VCD,         PARAMFLAG_BOOL,  iptr:&vcdflag,                            defintval:0,     TYPE_INT,    0}, \
-    {"rrc_config_path",          CONFIG_HLP_RRC_CFG_PATH,0,               strptr:(char **)&rrc_config_path,         defstrval:"./",  TYPE_STRING, 0}, \
+    {"V" ,                       CONFIG_HLP_VCD,         PARAMFLAG_BOOL,  iptr:&vcdflag,                      defintval:0,     TYPE_INT,    0}, \
+    {"uecap_file",               CONFIG_HLP_UECAP_FILE,  0,               strptr:(char **)&uecap_file,        defstrval:"./uecap.xml", TYPE_STRING, 0}, \
+    {"rrc_config_path",          CONFIG_HLP_RRC_CFG_PATH,0,               strptr:(char **)&rrc_config_path,   defstrval:"./",  TYPE_STRING, 0}, \
     {"ue-idx-standalone",        NULL,                   0,               u16ptr:&ue_idx_standalone,          defuintval:0xFFFF,    TYPE_UINT16,   0} \
 }
 
@@ -85,7 +86,7 @@ extern nrUE_params_t *get_nrUE_params(void);
 // In nr-ue.c
 extern int setup_nr_ue_buffers(PHY_VARS_NR_UE **phy_vars_ue, openair0_config_t *openair0_cfg);
 extern void fill_ue_band_info(void);
-extern void init_NR_UE(int, char*);
+extern void init_NR_UE(int, char*, char*);
 extern void init_NR_UE_threads(int);
 extern void reset_opp_meas(void);
 extern void print_opp_meas(void);