remove all usage of RC.ru global var in ocp-gnb and nr-uesoftmodem

cmake_targets/CMakeLists.txt

@@ -1593,6 +1593,7 @@ add_library(PHY_COMMON ${PHY_SRC_COMMON})
 add_dependencies(PHY_COMMON rrc_flag)
 add_dependencies(PHY_COMMON dfts)
 add_library(PHY ${PHY_SRC})
+
 add_dependencies(PHY rrc_flag)
 add_library(PHY_UE ${PHY_SRC_UE})
 add_dependencies(PHY_UE rrc_flag)
@@ -2417,7 +2418,7 @@ target_link_libraries(gnbscope ${XFORMS_LIBRARIES})
 add_library(rfsimulator MODULE 
 	${OPENAIR_TARGETS}/ARCH/rfsimulator/simulator.c
 	)
-target_link_libraries(rfsimulator SIMU ${ATLAS_LIBRARIES})
+target_link_libraries(rfsimulator ${ATLAS_LIBRARIES})
 
 add_library(oai_iqplayer MODULE 
 	${OPENAIR_TARGETS}/ARCH/iqplayer/iqplayer_lib.c
@@ -2711,7 +2712,7 @@ add_executable(ocp-gnb
 target_link_libraries (ocp-gnb
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_NR_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
-  ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} RRC_LIB NR_RRC_LIB 
+  ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} RRC_LIB NR_RRC_LIB 
   S1AP_LIB S1AP_ENB L2 L2_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   X2AP_LIB X2AP_ENB F1AP_LIB F1AP M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB ${PROTO_AGENT_LIB} ${FSPT_MSG_LIB}
   -Wl,--end-group z dl)
@@ -2720,7 +2721,7 @@ target_link_libraries (ocp-gnb ${LIBXML2_LIBRARIES})
 target_link_libraries (ocp-gnb pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (ocp-gnb ${LIB_LMS_LIBRARIES})
 target_link_libraries (ocp-gnb ${T_LIB})
-add_dependencies(ocp-gnb ldpc_orig ldpc_optim ldpc_optim8seg ldpc )
+add_dependencies(ocp-gnb ldpc_orig ldpc_optim ldpc_optim8seg ldpc params_libconfig rfsimulator oai_usrpdevif)
 
 
 # nr-uesoftmodem is  UE implementation
@@ -2853,6 +2854,7 @@ target_link_libraries(ldpctest
 add_executable(nr_dlschsim  
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlschsim.c 
   ${OPENAIR_DIR}/common/utils/system.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )
@@ -2864,6 +2866,7 @@ target_link_libraries(nr_dlschsim
 add_executable(nr_pbchsim  
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/pbchsim.c 
   ${OPENAIR_DIR}/common/utils/system.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )
@@ -2878,6 +2881,7 @@ add_executable(nr_pucchsim
   ${OPENAIR_DIR}/common/utils/backtrace.c
   ${OPENAIR_DIR}/common/utils/nr/nr_common.c
   ${OPENAIR_DIR}/common/utils/system.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )
@@ -2891,6 +2895,7 @@ add_executable(nr_dlsim
   ${OPENAIR_DIR}/common/utils/system.c
   ${OPENAIR_DIR}/common/utils/nr/nr_common.c
   ${OPENAIR_DIR}/executables/softmodem-common.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )   
@@ -2905,6 +2910,7 @@ add_executable(nr_prachsim
   ${OPENAIR_DIR}/common/utils/system.c
   ${OPENAIR_DIR}/common/utils/nr/nr_common.c
   ${OPENAIR1_DIR}/SCHED_NR/phy_procedures_nr_common.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES})
 target_link_libraries(nr_prachsim  
@@ -2913,6 +2919,7 @@ target_link_libraries(nr_prachsim
 add_executable(nr_ulschsim
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulschsim.c
   ${OPENAIR_DIR}/common/utils/system.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )
@@ -2926,6 +2933,7 @@ add_executable(nr_ulsim
   ${OPENAIR_DIR}/common/utils/system.c
   ${OPENAIR_DIR}/common/utils/nr/nr_common.c
   ${OPENAIR_DIR}/executables/softmodem-common.c
+  ${UTIL_SRC}
   ${T_SOURCE}
   ${SHLIB_LOADER_SOURCES}
   )

cmake_targets/tools/build_helper

@@ -623,6 +623,7 @@ check_install_oai_software() {
 	build-essential \
 	cmake \
 	cmake-curses-gui  \
+        ninja-build \
 	doxygen \
 	doxygen-gui \
 	texlive-latex-base \
@@ -782,7 +783,7 @@ install_asn1c_from_source(){
 
 install_nas_tools() {
   if [ ! -f .ue.nvram0 ]; then
-    echo_success "generate .ue_emm.nvram .ue.nvram ./nvram --gen -c $1 -o $2"
+    echo_success "generate .ue_emm.nvram .ue.nvram"
     ./nvram --gen -c $1 -o $2
   else
     [ ./nvram -nt .ue.nvram0 -o ./nvram -nt .ue_emm.nvram0 ] && ./nvram --gen -c $1 -o $2

common/ran_context.h

@@ -110,6 +110,7 @@ typedef struct {
   /// GTPu descriptor 
   gtpv1u_data_t *gtpv1u_data_g;
   /// RU descriptors. These describe what each radio unit is supposed to do and contain the necessary functions for fronthaul interfaces
+  // LTS: not coherent (xxx_frame_parms cardinatlity wtih xNB (so one carrier))
   struct RU_t_s **ru;
   /// Mask to indicate fronthaul setup status of RU (hard-limit to 64 RUs)
   uint64_t ru_mask;

executables/ocp-gnb.c

@@ -90,6 +90,16 @@ time_stats_t softmodem_stats_rxtx_sf; // total tx time
 time_stats_t nfapi_meas; // total tx time
 time_stats_t softmodem_stats_rx_sf; // total rx time
 
+AGENT_RRC_xface *agent_rrc_xface[NUM_MAX_ENB];
+AGENT_MAC_xface *agent_mac_xface[NUM_MAX_ENB];
+int flexran_agent_start(mid_t mod_id) {
+  memset (agent_rrc_xface, 0, sizeof(agent_rrc_xface));
+  memset (agent_mac_xface, 0, sizeof(agent_mac_xface));
+  return 0;
+}
+void flexran_agent_slice_update(mid_t module_idP) {
+}
+
 int split73=0;
 void sendFs6Ul(PHY_VARS_eNB *eNB, int UE_id, int harq_pid, int segmentID, int16_t *data, int dataLen, int r_offset) {
   AssertFatal(false, "Must not be called in this context\n");
@@ -240,15 +250,12 @@ void init_gNB_proc(int inst) {
 
 /// eNB kept in function name for nffapi calls, TO FIX
 void init_gNB_phase2(void) {
-  int inst,ru_id,i,aa;
+  int inst;
   LOG_I(PHY,"%s() RC.nb_nr_inst:%d\n", __FUNCTION__, RC.nb_nr_inst);
 
   for (inst=0; inst<RC.nb_nr_inst; inst++) {
     LOG_I(PHY,"RC.nb_nr_CC[inst:%d]:%p\n", inst, RC.gNB[inst]);
     PHY_VARS_gNB *gNB =  RC.gNB[inst];
-    gNB->RU_list[0] = RC.ru[0];
-    gNB->num_RU=1;
-    RC.ru[0]->nr_frame_parms=&RC.gNB[inst]->frame_parms;
     LOG_E(PHY,"hard coded gNB->num_RU:%d\n", gNB->num_RU);
     phy_init_nr_gNB(gNB,0,0);
     //init_precoding_weights(RC.gNB[inst][CC_id]);
@@ -369,129 +376,94 @@ static  void wait_nfapi_init(char *thread_name) {
 }
 
 void exit_function(const char *file, const char *function, const int line, const char *s) {
-  int ru_id;
-
   if (s != NULL) {
     printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
   }
 
   oai_exit = 1;
-
-  if (RC.ru == NULL)
-    exit(-1); // likely init not completed, prevent crash or hang, exit now...
-
-  for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
-    if (RC.ru[ru_id] && RC.ru[ru_id]->rfdevice.trx_end_func) {
-      RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
-      RC.ru[ru_id]->rfdevice.trx_end_func = NULL;
-    }
-
-    if (RC.ru[ru_id] && RC.ru[ru_id]->ifdevice.trx_end_func) {
-      RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
-      RC.ru[ru_id]->ifdevice.trx_end_func = NULL;
-    }
-  }
-
   sleep(1); //allow lte-softmodem threads to exit first
   exit(1);
 }
 
 void stop_RU(int nb_ru) {
+  return;
 }
 
-void RCconfig_RU(void) {
-  int i = 0, j = 0;
+void OCPconfig_RU(RU_t *ru) {
+  int i = 0, j = 0; // Ru and gNB cardinality
   paramdef_t RUParams[] = RUPARAMS_DESC;
   paramlist_def_t RUParamList = {CONFIG_STRING_RU_LIST,NULL,0};
   config_getlist( &RUParamList, RUParams, sizeof(RUParams)/sizeof(paramdef_t), NULL);
-
-  if ( RUParamList.numelt > 0) {
-    RC.ru = (RU_t **)malloc(RC.nb_RU*sizeof(RU_t *));
-    RC.ru_mask=(1<<RC.nb_RU) - 1;
+  AssertFatal( RUParamList.numelt == 1 && RC.nb_nr_L1_inst ==1,""  );
   printf("Set RU mask to %lx\n",RC.ru_mask);
-
-    for (j = 0; j < RC.nb_RU; j++) {
-      RC.ru[j]                                      = (RU_t *)malloc(sizeof(RU_t));
-      memset((void *)RC.ru[j],0,sizeof(RU_t));
-      RC.ru[j]->idx                                 = j;
-      RC.ru[j]->nr_frame_parms                      = (NR_DL_FRAME_PARMS *)malloc(sizeof(NR_DL_FRAME_PARMS));
-      RC.ru[j]->frame_parms                         = (LTE_DL_FRAME_PARMS *)malloc(sizeof(LTE_DL_FRAME_PARMS));
-      printf("Creating RC.ru[%d]:%p\n", j, RC.ru[j]);
-      RC.ru[j]->if_timing                           = synch_to_ext_device;
-
-      if (RC.nb_nr_L1_inst >0)
-        RC.ru[j]->num_gNB                           = RUParamList.paramarray[j][RU_ENB_LIST_IDX].numelt;
-      else
-        RC.ru[j]->num_gNB                           = 0;
-
-      for (i=0; i<RC.ru[j]->num_gNB; i++) RC.ru[j]->gNB_list[i] = &RC.gNB[RUParamList.paramarray[j][RU_ENB_LIST_IDX].iptr[i]][0];
+  ru->idx=0;
+  ru->nr_frame_parms                      = (NR_DL_FRAME_PARMS *)malloc(sizeof(NR_DL_FRAME_PARMS));
+  ru->frame_parms                         = (LTE_DL_FRAME_PARMS *)malloc(sizeof(LTE_DL_FRAME_PARMS));
+  ru->if_timing                           = synch_to_ext_device;
+  ru->num_gNB                           = RUParamList.paramarray[j][RU_ENB_LIST_IDX].numelt;
+  ru->gNB_list[i] = &RC.gNB[RUParamList.paramarray[j][RU_ENB_LIST_IDX].iptr[i]][0];
 
   if (config_isparamset(RUParamList.paramarray[j], RU_SDR_ADDRS)) {
-        RC.ru[j]->openair0_cfg.sdr_addrs = strdup(*(RUParamList.paramarray[j][RU_SDR_ADDRS].strptr));
+    ru->openair0_cfg.sdr_addrs = strdup(*(RUParamList.paramarray[j][RU_SDR_ADDRS].strptr));
   }
 
   if (config_isparamset(RUParamList.paramarray[j], RU_SDR_CLK_SRC)) {
     if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "internal") == 0) {
-          RC.ru[j]->openair0_cfg.clock_source = internal;
+      ru->openair0_cfg.clock_source = internal;
       LOG_D(PHY, "RU clock source set as internal\n");
     } else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "external") == 0) {
-          RC.ru[j]->openair0_cfg.clock_source = external;
+      ru->openair0_cfg.clock_source = external;
       LOG_D(PHY, "RU clock source set as external\n");
     } else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "gpsdo") == 0) {
-          RC.ru[j]->openair0_cfg.clock_source = gpsdo;
+      ru->openair0_cfg.clock_source = gpsdo;
       LOG_D(PHY, "RU clock source set as gpsdo\n");
     } else {
       LOG_E(PHY, "Erroneous RU clock source in the provided configuration file: '%s'\n", *(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr));
     }
   } else {
-        RC.ru[j]->openair0_cfg.clock_source = unset;
+    ru->openair0_cfg.clock_source = unset;
   }
 
   if (strcmp(*(RUParamList.paramarray[j][RU_LOCAL_RF_IDX].strptr), "yes") == 0) {
     if ( !(config_isparamset(RUParamList.paramarray[j],RU_LOCAL_IF_NAME_IDX)) ) {
-          RC.ru[j]->if_south                        = LOCAL_RF;
-          RC.ru[j]->function                        = gNodeB_3GPP;
+      ru->if_south                        = LOCAL_RF;
+      ru->function                        = gNodeB_3GPP;
       printf("Setting function for RU %d to gNodeB_3GPP\n",j);
     } else {
     }
 
-        RC.ru[j]->max_pdschReferenceSignalPower     = *(RUParamList.paramarray[j][RU_MAX_RS_EPRE_IDX].uptr);;
-        RC.ru[j]->max_rxgain                        = *(RUParamList.paramarray[j][RU_MAX_RXGAIN_IDX].uptr);
-        RC.ru[j]->num_bands                         = RUParamList.paramarray[j][RU_BAND_LIST_IDX].numelt;
+    ru->max_pdschReferenceSignalPower     = *(RUParamList.paramarray[j][RU_MAX_RS_EPRE_IDX].uptr);;
+    ru->max_rxgain                        = *(RUParamList.paramarray[j][RU_MAX_RXGAIN_IDX].uptr);
+    ru->num_bands                         = RUParamList.paramarray[j][RU_BAND_LIST_IDX].numelt;
 
-        for (i=0; i<RC.ru[j]->num_bands; i++) RC.ru[j]->band[i] = RUParamList.paramarray[j][RU_BAND_LIST_IDX].iptr[i];
+    for (i=0; i<ru->num_bands; i++) ru->band[i] = RUParamList.paramarray[j][RU_BAND_LIST_IDX].iptr[i];
   } //strcmp(local_rf, "yes") == 0
   else {
   }
 
-      RC.ru[j]->nb_tx                             = *(RUParamList.paramarray[j][RU_NB_TX_IDX].uptr);
-      RC.ru[j]->nb_rx                             = *(RUParamList.paramarray[j][RU_NB_RX_IDX].uptr);
-      RC.ru[j]->att_tx                            = *(RUParamList.paramarray[j][RU_ATT_TX_IDX].uptr);
-      RC.ru[j]->att_rx                            = *(RUParamList.paramarray[j][RU_ATT_RX_IDX].uptr);
+  ru->nb_tx                             = *(RUParamList.paramarray[j][RU_NB_TX_IDX].uptr);
+  ru->nb_rx                             = *(RUParamList.paramarray[j][RU_NB_RX_IDX].uptr);
+  ru->att_tx                            = *(RUParamList.paramarray[j][RU_ATT_TX_IDX].uptr);
+  ru->att_rx                            = *(RUParamList.paramarray[j][RU_ATT_RX_IDX].uptr);
 
   if (config_isparamset(RUParamList.paramarray[j], RU_BF_WEIGHTS_LIST_IDX)) {
-        RC.ru[j]->nb_bfw = RUParamList.paramarray[j][RU_BF_WEIGHTS_LIST_IDX].numelt;
+    ru->nb_bfw = RUParamList.paramarray[j][RU_BF_WEIGHTS_LIST_IDX].numelt;
 
-        for (i=0; i<RC.ru[j]->num_gNB; i++)  {
-          RC.ru[j]->bw_list[i] = (int32_t *)malloc16_clear((RC.ru[j]->nb_bfw)*sizeof(int32_t));
+    for (i=0; i<ru->num_gNB; i++)  {
+      ru->bw_list[i] = (int32_t *)malloc16_clear((ru->nb_bfw)*sizeof(int32_t));
 
-          for (int b=0; b<RC.ru[j]->nb_bfw; b++) RC.ru[j]->bw_list[i][b] = RUParamList.paramarray[j][RU_BF_WEIGHTS_LIST_IDX].iptr[b];
+      for (int b=0; b<ru->nb_bfw; b++) ru->bw_list[i][b] = RUParamList.paramarray[j][RU_BF_WEIGHTS_LIST_IDX].iptr[b];
     }
   }
-    }// j=0..num_rus
-  } else {
-    RC.nb_RU = 0;
-  } // setting != NULL
 
   return;
 }
 
-int rx_rf(RU_proc_t *proc, NR_DL_FRAME_PARMS *fp,int nb_rx, int32_t** rxdata, int lastReadSz,
-	  openair0_device* rfdevice,  openair0_timestamp ts_offset) {
+int rx_rf(RU_proc_t *proc, NR_DL_FRAME_PARMS *fp,int nb_rx, int32_t **rxdata, int lastReadSz,
+          openair0_device *rfdevice,  openair0_timestamp ts_offset) {
   void *rxp[nb_rx];
   int nextSlot=(proc->tti_rx+1)%fp->slots_per_frame;
   uint32_t samples_per_slot = fp->get_samples_per_slot(nextSlot,fp);
-
   int rxBufOffet=fp->get_samples_slot_timestamp(nextSlot,fp,0);
   int controlrxBufOffet=(proc->timestamp_rx+lastReadSz)%fp->samples_per_frame;
   AssertFatal(rxBufOffet == controlrxBufOffet &&
@@ -527,11 +499,7 @@ void tx_rf(RU_t *ru,int frame,int slot, uint64_t timestamp) {
   RU_proc_t *proc = &ru->proc;
   NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
   nfapi_nr_config_request_scf_t *cfg = &ru->gNB_list[0]->gNB_config;
-  void *txp[ru->nb_tx];
-  unsigned int txs;
   int i,txsymb;
-  T(T_ENB_PHY_OUTPUT_SIGNAL, T_INT(0), T_INT(0), T_INT(frame), T_INT(slot),
-    T_INT(0), T_BUFFER(&ru->common.txdata[0][fp->get_samples_slot_timestamp(slot,fp,0)], fp->samples_per_subframe * 4));
   int slot_type         = nr_slot_select(cfg,frame,slot%fp->slots_per_frame);
   int prevslot_type     = nr_slot_select(cfg,frame,(slot+(fp->slots_per_frame-1))%fp->slots_per_frame);
   int nextslot_type     = nr_slot_select(cfg,frame,(slot+1)%fp->slots_per_frame);
@@ -588,17 +556,13 @@ void tx_rf(RU_t *ru,int frame,int slot, uint64_t timestamp) {
       flags |= beam<<8;
     }
 
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_WRITE_FLAGS, flags );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, frame );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, slot );
+    void *txp[ru->nb_tx];
 
     for (i=0; i<ru->nb_tx; i++)
       txp[i] = (void *)&ru->common.txdata[i][fp->get_samples_slot_timestamp(slot,fp,0)-sf_extension];
 
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, (timestamp-ru->openair0_cfg.tx_sample_advance)&0xffffffff );
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );
     // prepare tx buffer pointers
-    txs = ru->rfdevice.trx_write_func(&ru->rfdevice,
+    unsigned int txs = ru->rfdevice.trx_write_func(&ru->rfdevice,
                        timestamp+ru->ts_offset-ru->openair0_cfg.tx_sample_advance-sf_extension,
                        txp,
                        siglen+sf_extension,
@@ -606,7 +570,6 @@ void tx_rf(RU_t *ru,int frame,int slot, uint64_t timestamp) {
                        flags);
     LOG_D(PHY,"[TXPATH] RU %d tx_rf, writing to TS %llu, frame %d, unwrapped_frame %d, slot %d\n",ru->idx,
           (long long unsigned int)timestamp,frame,proc->frame_tx_unwrap,slot);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
     AssertFatal(txs ==  siglen+sf_extension,"TX : Timeout (sent %u/%d)\n", txs, siglen);
   }
 }
@@ -806,14 +769,13 @@ static void *ru_thread( void *param ) {
   static int ru_thread_status = 0;
   return &ru_thread_status;
 }
-void launch_NR_RU(char *rf_config_file) {
+void launch_NR_RU(RU_t *ru, char *rf_config_file) {
   LOG_I(PHY,"number of L1 instances %d, number of RU %d, number of CPU cores %d\n",
         RC.nb_nr_L1_inst,RC.nb_RU,get_nprocs());
   LOG_D(PHY,"Process RUs RC.nb_RU:%d\n",RC.nb_RU);
 
   for (int ru_id=0; ru_id<RC.nb_RU; ru_id++) {
     LOG_D(PHY,"Process RC.ru[%d]\n",ru_id);
-    RU_t *ru                 = RC.ru[ru_id];
     ru->rf_config_file = rf_config_file;
     ru->idx            = ru_id;
     ru->ts_offset      = 0;
@@ -825,7 +787,6 @@ void launch_NR_RU(char *rf_config_file) {
     ru->gNB_list[0] = &RC.gNB[0][0];
     ru->num_gNB=1;
     LOG_I(PHY,"Copying frame parms from gNB in RC to ru %d and frame_parms in ru\n",ru->idx);
-    memcpy((void *)ru->nr_frame_parms,&RC.gNB[0][0].frame_parms,sizeof(NR_DL_FRAME_PARMS));
     RU_proc_t *proc = &ru->proc;
     threadCreate( &proc->pthread_FH, ru_thread, (void *)ru, "thread_FH", -1, OAI_PRIORITY_RT_MAX );
   }
@@ -894,16 +855,18 @@ int main( int argc, char **argv ) {
   // once all RUs are ready initialize the rest of the gNBs ((dependence on final RU parameters after configuration)
   printf("ALL RUs ready - init gNBs\n");
   LOG_E(PHY,"configuring RU from file,  hardcoded one gNB for one RU, one carrier\n");
-  RCconfig_RU();
-  RC.ru[0]->nr_frame_parms->threequarter_fs=threequarter_fs;
-  fill_rf_config(RC.ru[0],RC.ru[0]->rf_config_file);
+  RU_t ru;
+  OCPconfig_RU(&ru);
+  ru.nr_frame_parms->threequarter_fs=threequarter_fs;
+  fill_rf_config(&ru,ru.rf_config_file);
   init_gNB_phase2();
-  nr_phy_init_RU(RC.ru[0]);
+  memcpy((void *)ru.nr_frame_parms,&RC.gNB[0][0].frame_parms,sizeof(NR_DL_FRAME_PARMS));
+  nr_phy_init_RU(&ru);
   init_gNB_proc(0); // only instance 0 (one gNB per process)
 
   if (RC.nb_RU >0) {
     printf("Initializing RU threads\n");
-    launch_NR_RU(get_softmodem_params()->rf_config_file);
+    launch_NR_RU(&ru, get_softmodem_params()->rf_config_file);
   }
 
   if (opp_enabled ==1) {
@@ -913,21 +876,13 @@ int main( int argc, char **argv ) {
   }
 
   if (do_forms==1) {
-    scopeParms_t tmp= {&argc, argv};
+    scopeParms_t tmp= {&argc, argv, NULL, NULL};
     startScope(&tmp);
   }
 
   while(!oai_exit)
     sleep(1);
 
-  for(int ru_id=0; ru_id<NB_RU; ru_id++) {
-    if (RC.ru[ru_id]->rfdevice.trx_end_func)
-      RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
-
-    if (RC.ru[ru_id]->ifdevice.trx_end_func)
-      RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
-  }
-
   logClean();
   printf("Bye.\n");
   return 0;

nfapi/oai_integration/nfapi_pnf.c

@@ -720,9 +720,6 @@ int pnf_phy_hi_dci0_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, nfa
 }
 
 int pnf_phy_dl_config_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, nfapi_dl_config_request_t *req) {
-  if (RC.ru == 0) {
-    return -1;
-  }
 
   if (RC.eNB == 0) {
     return -2;
@@ -847,9 +844,6 @@ int pnf_phy_ul_config_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, n
                 req->ul_config_request_body.srs_present
                );
 
-  if (RC.ru == 0) {
-    return -1;
-  }
 
   if (RC.eNB == 0) {
     return -2;

openair1/PHY/LTE_ESTIMATION/lte_adjust_sync_eNB.c

@@ -112,18 +112,12 @@ int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
 }
 
 
-int lte_est_timing_advance_pusch(PHY_VARS_eNB *eNB,
-                                 module_id_t UE_id)
+int lte_est_timing_advance_pusch(LTE_DL_FRAME_PARMS *frame_parms,
+                                 int32_t **ul_ch_estimates_time)
 {
   int temp, i, aa, max_pos=0, max_val=0;
   short Re,Im;
 
-  RU_t *ru;
-  ru = RC.ru[UE_id];
-  LTE_DL_FRAME_PARMS *frame_parms = (eNB==NULL) ? ru->frame_parms : &eNB->frame_parms;
-  LTE_eNB_PUSCH *eNB_pusch_vars = (eNB!=NULL) ? eNB->pusch_vars[UE_id] : (LTE_eNB_PUSCH*)NULL;
-  RU_CALIBRATION *calibration = &ru->calibration;
-  int32_t **ul_ch_estimates_time = (eNB==NULL) ? calibration->drs_ch_estimates_time : eNB_pusch_vars->drs_ch_estimates_time;
   uint8_t cyclic_shift = 0;
   int sync_pos = (frame_parms->ofdm_symbol_size-cyclic_shift*frame_parms->ofdm_symbol_size/12)%(frame_parms->ofdm_symbol_size);
   
@@ -149,7 +143,7 @@ int lte_est_timing_advance_pusch(PHY_VARS_eNB *eNB,
     max_pos = max_pos-frame_parms->ofdm_symbol_size;
 
   //#ifdef DEBUG_PHY
-  LOG_D(PHY,"frame %d: max_pos = %d, sync_pos=%d\n",eNB->proc.frame_rx,max_pos,sync_pos);
+  LOG_D(PHY,"max_pos = %d, sync_pos=%d\n",max_pos,sync_pos);
   //#endif //DEBUG_PHY
 
   return max_pos - sync_pos;

openair1/PHY/LTE_ESTIMATION/lte_estimation.h

@@ -220,11 +220,15 @@ void phy_adjust_gain (PHY_VARS_UE *phy_vars_ue,
                       uint32_t rx_power_fil_dB,
                       unsigned char eNB_id);
 
-int lte_ul_channel_estimation(PHY_VARS_eNB *phy_vars_eNB,
+int32_t lte_ul_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
                                   L1_rxtx_proc_t *proc,
+				  LTE_eNB_ULSCH_t * ulsch,
+				  int32_t **ul_ch_estimates,
+				  int32_t **ul_ch_estimates_time,
+				  int32_t **rxdataF_ext,
 				  module_id_t UE_id,
-                              uint8_t l,
-                              uint8_t Ns);
+                                  unsigned char l,
+                                  unsigned char Ns);
 
 int32_t lte_ul_channel_estimation_RRU(LTE_DL_FRAME_PARMS *frame_parms,
                                       int32_t **ul_ch_estimates,
@@ -258,7 +262,8 @@ int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
                            unsigned char number_of_cards,
                            short coef);
 
-int lte_est_timing_advance_pusch(PHY_VARS_eNB* phy_vars_eNB,module_id_t UE_id);
+int lte_est_timing_advance_pusch(LTE_DL_FRAME_PARMS *frame_parms,
+                                 int32_t **ul_ch_estimates_time);
 
 void lte_eNB_I0_measurements(PHY_VARS_eNB *phy_vars_eNB,
                              int subframe,

openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c

@@ -34,23 +34,17 @@ static int16_t ru_90c[2*128] = {32767, 0,32766, -402,32758, -804,32746, -1206,32
 
 #define SCALE 0x3FFF
 
-int32_t lte_ul_channel_estimation(PHY_VARS_eNB *eNB,
+int32_t lte_ul_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
                                   L1_rxtx_proc_t *proc,
+				  LTE_eNB_ULSCH_t * ulsch,
+				  int32_t **ul_ch_estimates,
+				  int32_t **ul_ch_estimates_time,
+				  int32_t **rxdataF_ext,
 				  module_id_t UE_id,
                                   unsigned char l,
                                   unsigned char Ns) {
-  RU_t *ru;
-  ru = RC.ru[UE_id];
-  LTE_DL_FRAME_PARMS *frame_parms = (eNB!=NULL) ? &eNB->frame_parms : ru->frame_parms;
-  LTE_eNB_PUSCH *pusch_vars = (eNB!=NULL) ? eNB->pusch_vars[UE_id] : NULL;
-  RU_CALIBRATION *calibration = &ru->calibration;
-  int32_t **ul_ch_estimates = (eNB!=NULL) ? pusch_vars->drs_ch_estimates : calibration->drs_ch_estimates;
-  AssertFatal(ul_ch_estimates != NULL, "ul_ch_estimates is null (eNB %p, pusch %p, pusch->drs_ch_estimates %p, pusch->drs_ch_estimates[0] %p ul_ch_estimates %p UE_id %d)\n",eNB,pusch_vars,
-              pusch_vars->drs_ch_estimates,pusch_vars->drs_ch_estimates[0],ul_ch_estimates,UE_id);
-  int32_t **ul_ch_estimates_time = (eNB!=NULL) ? pusch_vars->drs_ch_estimates_time : calibration->drs_ch_estimates_time;
+  AssertFatal(ul_ch_estimates != NULL, "ul_ch_estimates is null ");
   AssertFatal(ul_ch_estimates_time != NULL, "ul_ch_estimates_time is null\n");
-  int32_t **rxdataF_ext = (eNB!=NULL) ? pusch_vars->rxdataF_ext : calibration->rxdataF_ext;
-
   int subframe = proc->subframe_rx;
 
   uint8_t harq_pid; 
@@ -83,16 +77,16 @@ int32_t lte_ul_channel_estimation(PHY_VARS_eNB *eNB,
 #endif
   int32_t temp_in_ifft_0[2048*2] __attribute__((aligned(32)));
 
-  if (eNB->ulsch[UE_id]->ue_type > 0) harq_pid = 0;
+  if (ulsch->ue_type > 0) harq_pid = 0;
   else {
     harq_pid = subframe2harq_pid(frame_parms,proc->frame_rx,subframe);
   }
 
-  uint16_t N_rb_alloc = eNB->ulsch[UE_id]->harq_processes[harq_pid]->nb_rb;
+  uint16_t N_rb_alloc = ulsch->harq_processes[harq_pid]->nb_rb;
   int32_t tmp_estimates[N_rb_alloc*12] __attribute__((aligned(16)));
   Msc_RS = N_rb_alloc*12;
   cyclic_shift = (frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift +
-                  eNB->ulsch[UE_id]->harq_processes[harq_pid]->n_DMRS2 +
+                  ulsch->harq_processes[harq_pid]->n_DMRS2 +
                   frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.nPRS[(subframe<<1)+Ns]) % 12;
   Msc_idx_ptr = (uint16_t *) bsearch(&Msc_RS, dftsizes, 34, sizeof(uint16_t), compareints);
 
@@ -276,7 +270,7 @@ int32_t lte_ul_channel_estimation(PHY_VARS_eNB *eNB,
 #if T_TRACER
 
       if (aa == 0)
-        T(T_ENB_PHY_UL_CHANNEL_ESTIMATE, T_INT(0), T_INT(eNB->ulsch[UE_id]->rnti),
+        T(T_ENB_PHY_UL_CHANNEL_ESTIMATE, T_INT(0), T_INT(ulsch->rnti),
           T_INT(proc->frame_rx), T_INT(subframe),
           T_INT(0), T_BUFFER(ul_ch_estimates_time[0], 512  * 4));
 

openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c

@@ -2432,6 +2432,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
       }
 
       // mapping ue specific beamforming weights from UE specified DLSCH structure to RU beam weights for the eNB
+      /*
       for (ru_id=0;ru_id<RC.nb_RU;ru_id++) {
 	ru = RC.ru[ru_id];
 	for (eNB_id=0;eNB_id<ru->num_eNB;eNB_id++){
@@ -2445,6 +2446,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 	  }
 	}
       }
+      */
 
     }
 

openair1/PHY/LTE_TRANSPORT/ulsch_demodulation.c

@@ -1047,7 +1047,11 @@ void rx_ulsch(PHY_VARS_eNB *eNB,
                              l%(frame_parms->symbols_per_tti/2),
                              l/(frame_parms->symbols_per_tti/2),
                              frame_parms);
-    lte_ul_channel_estimation(eNB,proc,
+    lte_ul_channel_estimation(&eNB->frame_parms,proc,
+		              eNB->ulsch[UE_id],
+		              eNB->pusch_vars[UE_id]->drs_ch_estimates,
+			      eNB->pusch_vars[UE_id]->drs_ch_estimates_time,
+			      eNB->pusch_vars[UE_id]->rxdataF_ext,
                               UE_id,
                               l%(frame_parms->symbols_per_tti/2),
                               l/(frame_parms->symbols_per_tti/2));

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -911,19 +911,18 @@ void reset_stats_gNB(FL_OBJECT *button,
 
 
 static void *scope_thread_gNB(void *arg) {
-  int UE_id;
-  int ue_cnt=0;
+  scopeParms_t * p=(scopeParms_t *) arg;	
 //# ifdef ENABLE_XFORMS_WRITE_STATS
 //  FILE *gNB_stats = fopen("gNB_stats.txt", "w");
 //#endif
 
   while (!oai_exit) {
-    ue_cnt=0;
+    int ue_cnt=0;
     
-    for(UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+    for(int UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
         if ((ue_cnt<scope_enb_num_ue)) {
           //this function needs to be written
-          phy_scope_gNB(form_gnb[ue_cnt], RC.gNB[0], RC.ru[0], UE_id);
+          phy_scope_gNB(form_gnb[ue_cnt], p->gNB, p->ru, UE_id);
           ue_cnt++;
         }
     }
@@ -983,5 +982,5 @@ void startScope(scopeParms_t * p) {
   } // UE_id
 
   pthread_t forms_thread;
-  threadCreate(&forms_thread, scope_thread_gNB, NULL, "scope", -1, OAI_PRIORITY_RT_LOW);
+  threadCreate(&forms_thread, scope_thread_gNB, p, "scope", -1, OAI_PRIORITY_RT_LOW);
 }

openair1/PHY/TOOLS/nr_phy_scope.h

@@ -69,19 +69,13 @@ typedef struct {
 typedef struct {
   int *argc;
   char **argv;
+  RU_t* ru;
+  PHY_VARS_gNB *gNB;
 } scopeParms_t;
 
 extern unsigned char scope_enb_num_ue;
-FD_phy_scope_gnb * create_phy_scope_gnb( void );
 FD_phy_scope_nrue * create_phy_scope_nrue( void );
 
-
-void phy_scope_gNB(FD_phy_scope_gnb *form,
-                   PHY_VARS_gNB *phy_vars_gnb,
-		   RU_t *phy_vars_ru,
-                   int UE_id);
-
-
 void phy_scope_nrUE(FD_phy_scope_nrue *form,
                   PHY_VARS_NR_UE *phy_vars_ue,
                   int eNB_id,
@@ -91,6 +85,5 @@ void phy_scope_nrUE(FD_phy_scope_nrue *form,
 
 void startScope(scopeParms_t * p);
 
-
 extern RAN_CONTEXT_t RC;
 #endif

openair1/SCHED/phy_procedures_lte_eNb.c

@@ -1419,7 +1419,7 @@ void fill_rx_indication(PHY_VARS_eNB *eNB,
   pdu->rx_indication_rel8.offset         = 1;   // DJP - I dont understand - but broken unless 1 ????  0;  // filled in at the end of the UL_INFO formation
   pdu->data                              = eNB->ulsch[UE_id]->harq_processes[harq_pid]->decodedBytes;
   // estimate timing advance for MAC
-  sync_pos                               = lte_est_timing_advance_pusch(eNB,UE_id);
+  sync_pos                               = lte_est_timing_advance_pusch(&eNB->frame_parms, eNB->pusch_vars[UE_id]->drs_ch_estimates_time);
   timing_advance_update                  = sync_pos; // - eNB->frame_parms.nb_prefix_samples/4; //to check
 
   //  if (timing_advance_update > 10) { dump_ulsch(eNB,frame,subframe,UE_id); exit(-1);}

openair1/SCHED/ru_procedures.c

@@ -693,12 +693,6 @@ void ru_fep_full_2thread(RU_t *ru,
                              3/(fp->symbols_per_tti/2),// Ns = slot number
                              fp);
         
-	/*lte_ul_channel_estimation((PHY_VARS_eNB *)NULL,
-                                proc,
-                                ru->idx,
-                                3%(fp->symbols_per_tti/2),
-                                3/(fp->symbols_per_tti/2));
-        */
 	lte_ul_channel_estimation_RRU(fp,
                                   calibration->drs_ch_estimates,
                                   calibration->drs_ch_estimates_time,
@@ -713,7 +707,7 @@ void ru_fep_full_2thread(RU_t *ru,
                                   0,//interpolate,
                                   0 /*eNB->ulsch[ru->idx]->rnti rnti or ru->ulsch[eNB_id]->rnti*/);
 
-	check_sync_pos = lte_est_timing_advance_pusch((PHY_VARS_eNB *)NULL, ru->idx);
+	check_sync_pos = lte_est_timing_advance_pusch(ru->frame_parms, ru->calibration.drs_ch_estimates_time); 
         if (ru->state == RU_CHECK_SYNC) {
           if ((check_sync_pos >= 0 && check_sync_pos<8) || (check_sync_pos < 0 && check_sync_pos>-8)) {
     		  LOG_I(PHY,"~~~~~~~~~~~    check_sync_pos %d, frame %d, cnt %d\n",check_sync_pos,proc->frame_rx,ru->wait_check); 

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c

@@ -1579,10 +1579,12 @@ int flexran_agent_unregister_mac_xface(mid_t mod_id)
   return 0;
 }
 
+#if 0
 AGENT_MAC_xface *flexran_agent_get_mac_xface(mid_t mod_id)
 {
   return agent_mac_xface[mod_id];
 }
+#endif
 
 void flexran_create_config_structures(mid_t mod_id)
 {

openair2/ENB_APP/CONTROL_MODULES/RRC/flexran_agent_rrc.c

@@ -921,7 +921,9 @@ int flexran_agent_unregister_rrc_xface(mid_t mod_id)
   return 0;
 }
 
+#if 0
 AGENT_RRC_xface *flexran_agent_get_rrc_xface(mid_t mod_id)
 {
   return agent_rrc_xface[mod_id];
 }
+#endif

openair2/ENB_APP/flexran_agent_extern.h

@@ -41,10 +41,15 @@
 AGENT_PHY_xface *flexran_agent_get_phy_xface(mid_t mod_id);
 
 /* Control module interface for the communication of the MAC Control Module with the agent */
-AGENT_MAC_xface *flexran_agent_get_mac_xface(mid_t mod_id);
+//AGENT_MAC_xface *flexran_agent_get_mac_xface(mid_t mod_id);
+extern AGENT_MAC_xface *agent_mac_xface[NUM_MAX_ENB];
+#define flexran_agent_get_mac_xface(mod_id) (agent_mac_xface[mod_id])
+
 
 /* Control module interface for the communication of the RRC Control Module with the agent */
-AGENT_RRC_xface *flexran_agent_get_rrc_xface(mid_t mod_id);
+// AGENT_RRC_xface *flexran_agent_get_rrc_xface(mid_t mod_id);
+extern AGENT_RRC_xface *agent_rrc_xface[NUM_MAX_ENB];
+#define flexran_agent_get_rrc_xface(mod_id) (agent_rrc_xface[mod_id])
 
 /* Control module interface for the communication of the RRC Control Module with the agent */
 AGENT_PDCP_xface *flexran_agent_get_pdcp_xface(mid_t mod_id);

targets/ARCH/rfsimulator/simulator.c

@@ -295,7 +295,7 @@ sin_addr:
   };
   bind(t->listen_sock, (struct sockaddr *)&addr, sizeof(addr));
   AssertFatal(listen(t->listen_sock, 5) == 0, "");
-  struct epoll_event ev={0};
+  struct epoll_event ev= {0};
   ev.events = EPOLLIN;
   ev.data.fd = t->listen_sock;
   AssertFatal(epoll_ctl(t->epollfd, EPOLL_CTL_ADD,  t->listen_sock, &ev) != -1, "");
@@ -368,6 +368,7 @@ static int rfsimulator_write_internal(rfsimulator_state_t *t, openair0_timestamp
   if (t->lastWroteTS > timestamp+nsamps)
     LOG_E(HW,"Not supported to send Tx out of order (same in USRP) %lu, %lu\n",
           t->lastWroteTS, timestamp);
+
   t->lastWroteTS=timestamp+nsamps;
 
   if (!alreadyLocked)
@@ -479,8 +480,8 @@ static bool flushInput(rfsimulator_state_t *t, int timeout, int nsamps_for_initi
 
           if (b->lastReceivedTS != 0 && b->th.timestamp-b->lastReceivedTS > 50 )
             LOG_W(HW,"UEsock: %d gap of: %ld in reception\n", fd, b->th.timestamp-b->lastReceivedTS );
-          b->lastReceivedTS=b->th.timestamp;
 
+          b->lastReceivedTS=b->th.timestamp;
         } else if ( b->lastReceivedTS > b->th.timestamp && b->th.size == 1 ) {
           LOG_W(HW,"Received Rx/Tx synchro out of order\n");
           b->trashingPacket=true;
@@ -561,6 +562,7 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
       pthread_mutex_unlock(&Sockmutex);
       usleep(10000);
       pthread_mutex_lock(&Sockmutex);
+
       if ( t->lastWroteTS < t->nextTimestamp ) {
         // Assuming Tx is not done fully in another thread
         // We can never write is the past from the received time
@@ -574,6 +576,7 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
 
         for ( int i=0; i < t->tx_num_channels; i++)
           samplesVoid[i]=(void *)&v;
+
         LOG_I(HW, "No samples Tx occured, so we send 1 sample to notify it: Tx:%lu, Rx:%lu\n",
               t->lastWroteTS, t->nextTimestamp);
         rfsimulator_write_internal(t, t->nextTimestamp,
@@ -712,7 +715,7 @@ int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
   rfsimulator->rx_num_channels=openair0_cfg->rx_num_channels;
   rfsimulator->sample_rate=openair0_cfg->sample_rate;
   rfsimulator->tx_bw=openair0_cfg->tx_bw;
-  randominit(0);
+  //randominit(0);
   set_taus_seed(0);
   return 0;
 }