add process for itti simulator

cmake_targets/CMakeLists.txt

@@ -879,6 +879,7 @@ add_boolean_option(UE_EXPANSION             False         "enable UE_EXPANSION w
 add_boolean_option(PHY_TX_THREAD            False         "enable UE_EXPANSION with max 256 UE")
 add_boolean_option(PRE_SCD_THREAD           False         "enable UE_EXPANSION with max 256 UE")
 add_boolean_option(UESIM_EXPANSION          False         "enable UESIM_EXPANSION with max 256 UE")
+add_boolean_option(ITTI_SIM                 False         "enable itti simulator")
 
 ########################
 # Include order
@@ -3211,7 +3212,7 @@ if (${T_TRACER})
   foreach(i
         #all "add_executable" definitions (except tests, rb_tool, updatefw)
         lte-softmodem lte-uesoftmodem nr-softmodem 
-        nr-uesoftmodem dlsim dlsim_tm4 dlsim_tm7 
+        nr-uesoftmodem dlsim dlsim_tm4 dlsim_tm7 nr-ittisim
         ulsim pbchsim scansim mbmssim pdcchsim pucchsim prachsim
         syncsim nr_ulsim nr_dlsim nr_dlschsim nr_pbchsim nr_pucchsim
         nr_ulschsim ldpctest polartest smallblocktest cu_test du_test
@@ -3298,6 +3299,60 @@ add_executable(rb_tool
 )
 target_include_directories(rb_tool PRIVATE ${OPENAIR2_DIR}/NETWORK_DRIVER/MESH/)
 
+# nr-ittisim
+###################################################
+
+add_executable(nr-ittisim
+  ${rrc_h}
+  ${nr_rrc_h}
+  ${OPENAIR2_DIR}/GNB_APP/gnb_app.c
+  ${OPENAIR2_DIR}/GNB_APP/gnb_config.c
+  ${OPENAIR_DIR}/executables/nr-gnb.c
+  ${OPENAIR_DIR}/executables/nr-ru.c
+  ${OPENAIR2_DIR}/SIMULATION/NR_RRC/itti_sim.c
+  ${OPENAIR_DIR}/executables/softmodem-common.c
+  ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
+  ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
+  ${OPENAIR_TARGETS}/ARCH/COMMON/record_player.c
+  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
+  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
+  ${OPENAIR3_DIR}/GTPV1-U/gtpv1u_gNB.c
+  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
+  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
+  ${OPENAIR_DIR}/common/utils/utils.c
+  ${OPENAIR_DIR}/common/utils/system.c
+  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
+  ${GTPU_need_ITTI}
+  ${XFORMSINTERFACE_SOURCE}
+  ${T_SOURCE}
+  ${CONFIG_SOURCES}
+  ${SHLIB_LOADER_SOURCES}
+  )
+
+#target_link_libraries (nr-ittisim
+#  -Wl,--start-group
+#  UTIL HASHTABLE SCTP_CLIENT UDP LFDS NR_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 
+#  NGAP_LIB NGAP_GNB S1AP_LIB S1AP_ENB
+#  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)
+
+target_link_libraries (nr-ittisim
+  -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 NR_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 
+  NGAP_LIB NGAP_GNB S1AP_LIB S1AP_ENB L2_LTE_NR 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}
+  NR_L2_UE
+  -Wl,--end-group z dl)
+
+target_link_libraries (nr-ittisim ${LIBXML2_LIBRARIES})
+target_link_libraries (nr-ittisim 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 (nr-ittisim ${LIB_LMS_LIBRARIES})
+target_link_libraries (nr-ittisim ${T_LIB})
+
+add_dependencies( nr-ittisim ldpc_orig ldpc_optim ldpc_optim8seg ldpc )
+
 # ???
 ####################
 list(APPEND oai_nw_drv_src device.c common.c ioctl.c classifier.c tool.c)

cmake_targets/build_oai

@@ -67,6 +67,7 @@ UE_TIMING_TRACE="False"
 USRP_REC_PLAY="False"
 BUILD_ECLIPSE=0
 NR="False"
+ITTI_SIM="False"
 OPTIONAL_LIBRARIES="telnetsrv enbscope uescope nrscope msc"
 trap handle_ctrl_c INT
 
@@ -160,6 +161,8 @@ Options
    Build for I/Q record-playback modes
 -k | --skip-shared-libraries
    Skip build for shared libraries to reduce compilation time when building frequently for debugging purposes
+--ittiSIM
+  Makes the itti simulator
 -h | --help
    Print this help
 
@@ -418,6 +421,11 @@ function main() {
         CMAKE_CMD="$CMAKE_CMD -GNinja"
 	MAKE_CMD=ninja
 	shift;;
+      --ittiSIM)
+            ittiSIM=1
+            ITTI_SIM="True"
+            echo_info "Will compile itti simulator"
+            shift;;
         -h | --help)
             print_help
             exit 1;;
@@ -580,7 +588,7 @@ function main() {
   config_libconfig_shlib=params_libconfig
   
   # first generate the CMakefile in the right directory
-  if [ "$eNB" = "1" -o "$eNBocp" = "1" -o "$UE" = "1" -o "$gNB" = "1" -o "$nrUE" = "1" -o "$HW" = "EXMIMO" ] ; then
+  if [ "$eNB" = "1" -o "$eNBocp" = "1" -o "$UE" = "1" -o "$gNB" = "1" -o "$nrUE" = "1" -o "$HW" = "EXMIMO" -o "$ittiSIM" = "1" ] ; then
 
     # softmodem compilation
 
@@ -605,6 +613,7 @@ function main() {
     echo "set ( UE_TIMING_TRACE $UE_TIMING_TRACE )"                       >> $cmake_file
     echo "set ( USRP_REC_PLAY $USRP_REC_PLAY )"                           >> $cmake_file
     echo "set ( SKIP_SHARED_LIB_FLAG $SKIP_SHARED_LIB_FLAG )"             >> $cmake_file
+    echo "set ( ITTI_SIM $ITTI_SIM )"                                     >> $cmake_file
     echo 'include(${CMAKE_CURRENT_SOURCE_DIR}/../CMakeLists.txt)'         >> $cmake_file
     cd  $DIR/$build_dir/build
     eval $CMAKE_CMD
@@ -626,6 +635,10 @@ function main() {
       execlist="$execlist nr-uesoftmodem"
     fi
 
+    if [ "$ittiSIM" = "1" ] ; then
+      execlist="$execlist nr-ittisim"
+    fi
+
     for f in $execlist ; do
       echo_info "Compiling $f..."
       compilations \

common/utils/ocp_itti/all_msg.h

@@ -17,3 +17,7 @@
 #include "openair2/COMMON/flexran_messages_def.h"
 #include "openair2/COMMON/f1ap_messages_def.h"
 #include "openair2/COMMON/ngap_messages_def.h"
+#if ITTI_SIM
+#include "openair2/COMMON/itti_sim_messages_def.h"
+#endif
+

common/utils/ocp_itti/intertask_interface.h

@@ -262,6 +262,10 @@ void *rrc_enb_process_itti_msg(void *);
 #include <openair3/SCTP/sctp_eNB_task.h>
 #include <openair3/NGAP/ngap_gNB.h>
 
+#ifdef ITTI_SIM
+#include <openair2/COMMON/itti_sim_messages_types.h>
+#endif
+
 /*
   static const char *const messages_definition_xml = {
   #include <messages_xml.h>
@@ -339,6 +343,8 @@ void * rrc_enb_process_msg(void*);
   TASK_DEF(TASK_UDP,      TASK_PRIORITY_MED,  1000, NULL, NULL)\
   TASK_DEF(TASK_CU_F1,    TASK_PRIORITY_MED,  200, NULL, NULL) \
   TASK_DEF(TASK_DU_F1,    TASK_PRIORITY_MED,  200, NULL, NULL) \
+  TASK_DEF(TASK_RRC_UE_SIM,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_RRC_GNB_SIM,  TASK_PRIORITY_MED,  200, NULL, NULL)  \
   TASK_DEF(TASK_MAX,      TASK_PRIORITY_MED,  200, NULL, NULL)
 
 #define TASK_DEF(TaskID, pRIO, qUEUEsIZE, FuNc, ThreadFunc)          { pRIO, qUEUEsIZE, #TaskID, FuNc, ThreadFunc },

openair2/COMMON/itti_sim_messages_def.h

+/*!
+\file itti_sim_messages_def.h
+
+\brief itti message for itti simulator
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+
+
+MESSAGE_DEF(GNB_RRC_BCCH_DATA_IND,          MESSAGE_PRIORITY_MED, itti_sim_rrc_ch_t,   GNBBCCHind)
+MESSAGE_DEF(GNB_RRC_CCCH_DATA_IND,          MESSAGE_PRIORITY_MED, itti_sim_rrc_ch_t,   GNBCCCHind)
+MESSAGE_DEF(GNB_RRC_DCCH_DATA_IND,          MESSAGE_PRIORITY_MED, itti_sim_rrc_ch_t,   GNBDCCHind)
+MESSAGE_DEF(UE_RRC_CCCH_DATA_IND,           MESSAGE_PRIORITY_MED, itti_sim_rrc_ch_t,   UECCCHind)
+MESSAGE_DEF(UE_RRC_DCCH_DATA_IND,           MESSAGE_PRIORITY_MED, itti_sim_rrc_ch_t,   UEDCCHind)

openair2/COMMON/itti_sim_messages_types.h

+/*!
+\file itti_sim_messages_types.h
+
+\brief itti message for itti simulator
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#ifndef ITTI_SIM_MESSAGES_TYPES_H_
+#define ITTI_SIM_MESSAGES_TYPES_H_
+
+#include "LTE_asn_constant.h"
+
+
+
+#define GNB_RRC_BCCH_DATA_IND(mSGpTR)           (mSGpTR)->ittiMsg.GNBBCCHind
+#define GNB_RRC_CCCH_DATA_IND(mSGpTR)           (mSGpTR)->ittiMsg.GNBCCCHind
+#define GNB_RRC_DCCH_DATA_IND(mSGpTR)           (mSGpTR)->ittiMsg.GNBDCCHind
+#define UE_RRC_CCCH_DATA_IND(mSGpTR)            (mSGpTR)->ittiMsg.UECCCHind
+#define UE_RRC_DCCH_DATA_IND(mSGpTR)            (mSGpTR)->ittiMsg.UEDCCHind
+
+
+
+typedef struct itti_sim_rrc_ch_s {
+    const rb_id_t                rbid;
+    uint8_t                     *sdu;
+    int                          size;
+} itti_sim_rrc_ch_t;
+
+#endif /* ITTI_SIM_MESSAGES_TYPES_H_ */

openair2/COMMON/tasks_def.h

@@ -74,6 +74,7 @@ TASK_DEF(TASK_PROTO_AGENT,  TASK_PRIORITY_MED,          200)
 
 ///   Radio Resource Control task
 TASK_DEF(TASK_RRC_UE,   TASK_PRIORITY_MED,          200)
+TASK_DEF(TASK_RRC_NRUE,   TASK_PRIORITY_MED,          200)
 ///   Non Access Stratum task
 TASK_DEF(TASK_NAS_UE,   TASK_PRIORITY_MED,          200)
 TASK_DEF(TASK_RAL_UE,   TASK_PRIORITY_MED,          200)
@@ -81,3 +82,8 @@ TASK_DEF(TASK_RAL_UE,   TASK_PRIORITY_MED,          200)
 //MESSAGE GENERATOR TASK
 TASK_DEF(TASK_MSC,      TASK_PRIORITY_MED,          200)
 
+#ifdef ITTI_SIM
+TASK_DEF(TASK_RRC_GNB_SIM,   TASK_PRIORITY_MED,          200)
+TASK_DEF(TASK_RRC_UE_SIM,    TASK_PRIORITY_MED,          200)
+#endif
+

openair2/RRC/LTE/defs_NB_IoT.h

@@ -37,6 +37,9 @@
 
 #include "COMMON/s1ap_messages_types.h"
 #include "COMMON/rrc_messages_types.h"
+#if ITTI_SIM
+#include "COMMON/itti_sim_messages_types.h"
+#endif
 
 #include "collection/tree.h"
 #include "rrc_types_NB_IoT.h"

openair2/RRC/NR/rrc_gNB.c

@@ -420,6 +420,13 @@ rrc_gNB_generate_RRCSetup(
     ue_context_pP->ue_context.ue_release_timer_thres = 1000;
     /* init timers */
     //   ue_context_pP->ue_context.ue_rrc_inactivity_timer = 0;
+#ifdef ITTI_SIM
+    MessageDef *message_p;
+    message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, GNB_RRC_CCCH_DATA_IND);
+    GNB_RRC_CCCH_DATA_IND (message_p).sdu = (uint8_t*)ue_p->Srb0.Tx_buffer.Payload;
+    GNB_RRC_CCCH_DATA_IND (message_p).size  = ue_p->Srb0.Tx_buffer.payload_size;
+    itti_send_msg_to_task (TASK_RRC_UE_SIM, ctxt_pP->instance, message_p);
+#endif
 }
 
 void

openair2/SIMULATION/NR_RRC/itti_sim.c

+/*!
+\file itti_sim.c
+
+\brief simulator for itti message from node to UE
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <sched.h>
+
+
+#include "T.h"
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+#include <common/utils/assertions.h>
+
+#include "msc.h"
+
+#include "common/ran_context.h"
+
+#include "common/config/config_userapi.h"
+#include "common/utils/load_module_shlib.h"
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "PHY/phy_vars.h"
+#include "SCHED/sched_common_vars.h"
+#include "LAYER2/MAC/mac_vars.h"
+#include "RRC/LTE/rrc_vars.h"
+#include "gnb_config.h"
+#include "SIMULATION/TOOLS/sim.h"
+
+#ifdef SMBV
+#include "PHY/TOOLS/smbv.h"
+unsigned short config_frames[4] = {2,9,11,13};
+#endif
+
+#include "common/utils/LOG/log.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "UTIL/OPT/opt.h"
+
+#ifndef OPENAIR2
+  #include "UTIL/OTG/otg_vars.h"
+#endif
+
+#include "intertask_interface.h"
+
+
+#include "system.h"
+#include <openair2/GNB_APP/gnb_app.h>
+#include "PHY/TOOLS/phy_scope_interface.h"
+#include "PHY/TOOLS/nr_phy_scope.h"
+#include "stats.h"
+#include "nr-softmodem.h"
+#include "executables/softmodem-common.h"
+#include "executables/thread-common.h"
+#include "NB_IoT_interface.h"
+#include "x2ap_eNB.h"
+#include "ngap_gNB.h"
+#include "RRC/NR_UE/rrc_proto.h"
+#include "openair3/NAS/UE/nas_ue_task.h"
+
+pthread_cond_t nfapi_sync_cond;
+pthread_mutex_t nfapi_sync_mutex;
+int nfapi_sync_var=-1; //!< protected by mutex \ref nfapi_sync_mutex
+
+uint8_t nfapi_mode = 0; // Default to monolithic mode
+uint32_t target_dl_mcs = 28;
+uint32_t target_ul_mcs = 20;
+uint32_t timing_advance = 0;
+uint64_t num_missed_slots=0;
+
+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");
+}
+
+pthread_cond_t sync_cond;
+pthread_mutex_t sync_mutex;
+int sync_var=-1; //!< protected by mutex \ref sync_mutex.
+int config_sync_var=-1;
+
+openair0_config_t openair0_cfg[MAX_CARDS];
+
+volatile int             start_gNB = 0;
+volatile int             oai_exit = 0;
+
+//static int wait_for_sync = 0;
+
+unsigned int mmapped_dma=0;
+int single_thread_flag=1;
+
+int8_t threequarter_fs=0;
+
+uint64_t downlink_frequency[MAX_NUM_CCs][4];
+int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
+
+//Temp fix for inexistent NR upper layer
+unsigned char NB_gNB_INST = 1;
+
+static char                    *itti_dump_file = NULL;
+
+int UE_scan = 1;
+int UE_scan_carrier = 0;
+runmode_t mode = normal_txrx;
+static double snr_dB=20;
+
+FILE *input_fd=NULL;
+
+int chain_offset=0;
+
+
+uint8_t dci_Format = 0;
+uint8_t agregation_Level =0xFF;
+
+uint8_t nb_antenna_tx = 1;
+uint8_t nb_antenna_rx = 1;
+
+char ref[128] = "internal";
+char channels[128] = "0";
+
+int otg_enabled;
+
+extern void *udp_eNB_task(void *args_p);
+
+int transmission_mode=1;
+int emulate_rf = 0;
+int numerology = 0;
+int usrp_tx_thread = 0;
+
+
+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
+ */
+uint8_t abstraction_flag=0;
+
+/* forward declarations */
+void set_default_frame_parms(nfapi_nr_config_request_scf_t *config[MAX_NUM_CCs], NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]);
+
+/*---------------------BMC: timespec helpers -----------------------------*/
+
+struct timespec min_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+struct timespec max_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+
+struct timespec clock_difftime(struct timespec start, struct timespec end) {
+  struct timespec temp;
+
+  if ((end.tv_nsec-start.tv_nsec)<0) {
+    temp.tv_sec = end.tv_sec-start.tv_sec-1;
+    temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
+  } else {
+    temp.tv_sec = end.tv_sec-start.tv_sec;
+    temp.tv_nsec = end.tv_nsec-start.tv_nsec;
+  }
+
+  return temp;
+}
+
+
+
+#define KNRM  "\x1B[0m"
+#define KRED  "\x1B[31m"
+#define KGRN  "\x1B[32m"
+#define KBLU  "\x1B[34m"
+#define RESET "\033[0m"
+
+
+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 wait_gNBs(void) {
+  int i;
+  int waiting=1;
+
+  while (waiting==1) {
+    printf("Waiting for gNB L1 instances to all get configured ... sleeping 50ms (nb_nr_sL1_inst %d)\n",RC.nb_nr_L1_inst);
+    usleep(50*1000);
+    waiting=0;
+
+    for (i=0; i<RC.nb_nr_L1_inst; i++) {
+
+      if (RC.gNB[i]->configured==0) {
+	waiting=1;
+	break;
+      }
+    }
+  }
+
+  printf("gNB L1 are configured\n");
+}
+
+void wait_RUs(void) {
+  LOG_I(PHY,"Waiting for RUs to be configured ... RC.ru_mask:%02lx\n", RC.ru_mask);
+  // wait for all RUs to be configured over fronthaul
+  pthread_mutex_lock(&RC.ru_mutex);
+
+  while (RC.ru_mask>0) {
+    pthread_cond_wait(&RC.ru_cond,&RC.ru_mutex);
+    printf("RC.ru_mask:%02lx\n", RC.ru_mask);
+  }
+
+  pthread_mutex_unlock(&RC.ru_mutex);
+  LOG_I(PHY,"RUs configured\n");
+}
+
+
+int stop_L1L2(module_id_t gnb_id) {
+  return 0;
+}
+
+int restart_L1L2(module_id_t gnb_id) {
+  return 0;
+}
+
+int create_gNB_tasks(uint32_t gnb_nb) {
+  LOG_D(GNB_APP, "%s(gnb_nb:%d)\n", __FUNCTION__, gnb_nb);
+  itti_wait_ready(1);
+
+
+  if (gnb_nb > 0) {
+    if(itti_create_task(TASK_SCTP, sctp_eNB_task, NULL) < 0){
+      LOG_E(SCTP, "Create task for SCTP failed\n");
+      return -1;
+    }
+    if (is_x2ap_enabled()) {
+    if(itti_create_task(TASK_X2AP, x2ap_task, NULL) < 0){
+      LOG_E(X2AP, "Create task for X2AP failed\n");
+    }
+    }
+    else {
+      LOG_I(X2AP, "X2AP is disabled.\n");
+    }
+  }
+
+  if (AMF_MODE_ENABLED && (get_softmodem_params()->phy_test==0 && get_softmodem_params()->do_ra==0)) {
+    if (gnb_nb > 0) {
+      if (itti_create_task (TASK_NGAP, ngap_gNB_task, NULL) < 0) {
+        LOG_E(S1AP, "Create task for NGAP failed\n");
+        return -1;
+      }
+
+
+      if(!emulate_rf){
+        if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
+          LOG_E(UDP_, "Create task for UDP failed\n");
+          return -1;
+        }
+      }
+
+      if (itti_create_task (TASK_GTPV1_U, &gtpv1u_gNB_task, NULL) < 0) {
+        LOG_E(GTPU, "Create task for GTPV1U failed\n");
+        return -1;
+      }
+    }
+  }
+
+
+  if (gnb_nb > 0) {
+    if (itti_create_task (TASK_GNB_APP, gNB_app_task, NULL) < 0) {
+      LOG_E(GNB_APP, "Create task for gNB APP failed\n");
+      return -1;
+    }
+    LOG_I(NR_RRC,"Creating NR RRC gNB Task\n");
+
+    if (itti_create_task (TASK_RRC_GNB, rrc_gnb_task, NULL) < 0) {
+      LOG_E(NR_RRC, "Create task for NR RRC gNB failed\n");
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+
+static void get_options(void) {
+
+
+  paramdef_t cmdline_params[] = CMDLINE_PARAMS_DESC_GNB ;
+
+  CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
+  get_common_options(SOFTMODEM_GNB_BIT );
+  config_process_cmdline( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL);
+  CONFIG_CLEARRTFLAG(CONFIG_NOEXITONHELP);
+
+
+
+
+  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT)) ) {
+    memset((void *)&RC,0,sizeof(RC));
+    /* Read RC configuration file */
+    NRRCConfig();
+    NB_gNB_INST = RC.nb_nr_inst;
+    NB_RU   = RC.nb_RU;
+    printf("Configuration: nb_rrc_inst %d, nb_nr_L1_inst %d, nb_ru %hhu\n",NB_gNB_INST,RC.nb_nr_L1_inst,NB_RU);
+  }
+
+}
+
+
+void set_default_frame_parms(nfapi_nr_config_request_scf_t *config[MAX_NUM_CCs],
+		             NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs])
+{
+  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    frame_parms[CC_id] = (NR_DL_FRAME_PARMS *) malloc(sizeof(NR_DL_FRAME_PARMS));
+    config[CC_id] = (nfapi_nr_config_request_scf_t *) malloc(sizeof(nfapi_nr_config_request_scf_t));
+    config[CC_id]->ssb_config.scs_common.value = 1;
+    config[CC_id]->cell_config.frame_duplex_type.value = 1; //FDD
+    config[CC_id]->carrier_config.dl_grid_size[1].value = 106;
+    config[CC_id]->carrier_config.ul_grid_size[1].value = 106;
+    config[CC_id]->cell_config.phy_cell_id.value = 0;
+  }
+}
+
+/*
+ * helper function to terminate a certain ITTI task
+ */
+void terminate_task(task_id_t task_id, module_id_t mod_id) {
+  LOG_I(GNB_APP, "sending TERMINATE_MESSAGE to task %s (%d)\n", itti_get_task_name(task_id), task_id);
+  MessageDef *msg;
+  msg = itti_alloc_new_message (ENB_APP, TERMINATE_MESSAGE);
+  itti_send_msg_to_task (task_id, ENB_MODULE_ID_TO_INSTANCE(mod_id), msg);
+}
+
+//extern void  free_transport(PHY_VARS_gNB *);
+extern void  nr_phy_free_RU(RU_t *);
+
+void init_pdcp(void) {
+  //if (!NODE_IS_DU(RC.rrc[0]->node_type)) {
+  pdcp_layer_init();
+  uint32_t pdcp_initmask = (IS_SOFTMODEM_NOS1) ?
+                           (PDCP_USE_NETLINK_BIT | LINK_ENB_PDCP_TO_IP_DRIVER_BIT) : LINK_ENB_PDCP_TO_GTPV1U_BIT;
+
+  if (IS_SOFTMODEM_NOS1) {
+    printf("IS_SOFTMODEM_NOS1 option enabled \n");
+    pdcp_initmask = pdcp_initmask | ENB_NAS_USE_TUN_BIT | SOFTMODEM_NOKRNMOD_BIT  ;
+  }
+
+  pdcp_module_init(pdcp_initmask);
+
+  pdcp_set_rlc_data_req_func((send_rlc_data_req_func_t) rlc_data_req);
+  pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) pdcp_data_ind);
+}
+
+
+int create_tasks_nrue(uint32_t ue_nb) {
+  LOG_D(ENB_APP, "%s(ue_nb:%d)\n", __FUNCTION__, ue_nb);
+  itti_wait_ready(1);
+
+  if (ue_nb > 0) {
+    printf("create TASK_RRC_NRUE\n");
+    if (itti_create_task (TASK_RRC_NRUE, rrc_nrue_task, NULL) < 0) {
+      LOG_E(RRC, "Create task for RRC UE failed\n");
+      return -1;
+    }
+  }
+
+
+  itti_wait_ready(0);
+  return 0;
+}
+
+
+void *itti_sim_ue_rrc_task( void *args_p) {
+  MessageDef   *msg_p, *message_p;
+  instance_t    instance;
+  unsigned int  ue_mod_id;
+  int           result;
+  itti_mark_task_ready (TASK_RRC_UE_SIM);
+
+  while(1) {
+    // Wait for a message
+    itti_receive_msg (TASK_RRC_UE_SIM, &msg_p);
+    instance = ITTI_MSG_INSTANCE (msg_p);
+    ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
+
+    switch (ITTI_MSG_ID(msg_p)) {
+      case TERMINATE_MESSAGE:
+        LOG_W(RRC, " *** Exiting RRC thread\n");
+        itti_exit_task ();
+        break;
+
+      case MESSAGE_TEST:
+        LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
+        break;
+      case GNB_RRC_BCCH_DATA_IND:
+          message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_MAC_BCCH_DATA_IND);
+          memset (NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu, 0, BCCH_SDU_SIZE);
+          NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu_size  = GNB_RRC_BCCH_DATA_IND(msg_p).size;
+          memcpy (NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu, GNB_RRC_BCCH_DATA_IND(msg_p).sdu, GNB_RRC_BCCH_DATA_IND(msg_p).size);
+          itti_send_msg_to_task (TASK_RRC_NRUE, instance, message_p);
+        break;
+      case GNB_RRC_CCCH_DATA_IND:
+        message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_MAC_CCCH_DATA_IND);
+        printf("receive GNB_RRC_CCCH_DATA_IND\n");
+        memset (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
+        memcpy (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, GNB_RRC_CCCH_DATA_IND(msg_p).sdu, GNB_RRC_CCCH_DATA_IND(msg_p).size);
+        NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu_size  = GNB_RRC_CCCH_DATA_IND(msg_p).size;
+        itti_send_msg_to_task (TASK_RRC_NRUE, instance, message_p);
+        break;
+      case GNB_RRC_DCCH_DATA_IND:
+        printf("receive GNB_RRC_DCCH_DATA_IND\n");
+        message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_DCCH_DATA_IND);
+        NR_RRC_DCCH_DATA_IND (message_p).dcch_index = GNB_RRC_DCCH_DATA_IND(msg_p).rbid;
+        NR_RRC_DCCH_DATA_IND (message_p).sdu_size   = GNB_RRC_DCCH_DATA_IND(msg_p).size;
+        memset(NR_RRC_DCCH_DATA_IND (message_p).sdu_p, 0, GNB_RRC_DCCH_DATA_IND(msg_p).size);
+        memcpy(NR_RRC_DCCH_DATA_IND (message_p).sdu_p, GNB_RRC_DCCH_DATA_IND(msg_p).sdu, GNB_RRC_DCCH_DATA_IND(msg_p).size);
+        itti_send_msg_to_task (TASK_RRC_NRUE, instance, message_p);
+        break;
+      default:
+        LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
+        break;
+    }
+
+    result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
+    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+    msg_p = NULL;
+  }
+}
+
+
+void *itti_sim_gnb_rrc_task( void *args_p) {
+  MessageDef   *msg_p, *message_p;
+  instance_t    instance;
+  unsigned int  ue_mod_id;
+  int           result;
+  itti_mark_task_ready (TASK_RRC_GNB_SIM);
+
+  while(1) {
+    // Wait for a message
+    itti_receive_msg (TASK_RRC_GNB_SIM, &msg_p);
+    instance = ITTI_MSG_INSTANCE (msg_p);
+    ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
+
+    switch (ITTI_MSG_ID(msg_p)) {
+      case TERMINATE_MESSAGE:
+        LOG_W(RRC, " *** Exiting RRC thread\n");
+        itti_exit_task ();
+        break;
+
+      case MESSAGE_TEST:
+        LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
+        break;
+      case UE_RRC_CCCH_DATA_IND:
+          message_p = itti_alloc_new_message (TASK_RRC_GNB, NR_RRC_MAC_CCCH_DATA_IND);
+          RRC_MAC_CCCH_DATA_IND (message_p).sdu_size = UE_RRC_CCCH_DATA_IND(msg_p).size;
+          memset (RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
+          memcpy (RRC_MAC_CCCH_DATA_IND (message_p).sdu, UE_RRC_CCCH_DATA_IND(msg_p).sdu, UE_RRC_CCCH_DATA_IND(msg_p).size);
+          itti_send_msg_to_task (TASK_RRC_GNB, instance, message_p);
+           break;
+      case UE_RRC_DCCH_DATA_IND:
+    	    message_p = itti_alloc_new_message (TASK_RRC_GNB, NR_RRC_DCCH_DATA_IND);
+    	    RRC_DCCH_DATA_IND (message_p).sdu_size   = UE_RRC_DCCH_DATA_IND(msg_p).size;
+            memset (RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, UE_RRC_DCCH_DATA_IND(msg_p).size);
+            memcpy (RRC_MAC_CCCH_DATA_IND (message_p).sdu, UE_RRC_DCCH_DATA_IND(msg_p).sdu, UE_RRC_DCCH_DATA_IND(msg_p).size);
+    	    itti_send_msg_to_task (TASK_RRC_GNB, instance, message_p);
+           break;
+
+      default:
+        LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
+        break;
+    }
+
+    result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
+    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+    msg_p = NULL;
+  }
+}
+
+
+int main( int argc, char **argv )
+{
+  start_background_system();
+
+  ///static configuration for NR at the moment
+  if ( load_configmodule(argc,argv,CONFIG_ENABLECMDLINEONLY) == NULL) {
+    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
+  }
+  set_softmodem_sighandler();
+#ifdef DEBUG_CONSOLE
+  setvbuf(stdout, NULL, _IONBF, 0);
+  setvbuf(stderr, NULL, _IONBF, 0);
+#endif
+
+  logInit();
+  //configure_linux();
+  printf("Reading in command-line options\n");
+  get_options ();
+
+  if (CONFIG_ISFLAGSET(CONFIG_ABORT) ) {
+    fprintf(stderr,"Getting configuration failed\n");
+    exit(-1);
+  }
+
+  AMF_MODE_ENABLED = !IS_SOFTMODEM_NOS1;
+
+#if T_TRACER
+  T_Config_Init();
+#endif
+  //randominit (0);
+  set_taus_seed (0);
+  printf("configuring for RAU/RRU\n");
+
+  if (opp_enabled ==1) {
+    reset_opp_meas();
+  }
+
+  cpuf=get_cpu_freq_GHz();
+  itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
+  // initialize mscgen log after ITTI
+  MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
+
+
+  init_opt();
+
+  LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);
+
+  if(IS_SOFTMODEM_NOS1)
+    init_pdcp();
+
+  if (RC.nb_nr_inst > 0)  {
+    // don't create if node doesn't connect to RRC/S1/GTP
+    AssertFatal(create_gNB_tasks(1) == 0,"cannot create ITTI tasks\n");
+  } else {
+    printf("No ITTI, Initializing L1\n");
+    return 0;
+  }
+
+  if(itti_create_task (TASK_RRC_GNB_SIM, itti_sim_gnb_rrc_task, NULL) < 0){
+    printf("cannot create ITTI tasks\n");
+    exit(-1); // need a softer mode
+  }
+
+  openair_rrc_top_init_ue_nr("./");
+
+  if (create_tasks_nrue(1) < 0) {
+    printf("cannot create ITTI tasks\n");
+    exit(-1); // need a softer mode
+  }
+
+  if(itti_create_task (TASK_RRC_UE_SIM, itti_sim_ue_rrc_task, NULL) < 0){
+    printf("cannot create ITTI tasks\n");
+    exit(-1); // need a softer mode
+  }
+
+  pthread_cond_init(&sync_cond,NULL);
+  pthread_mutex_init(&sync_mutex, NULL);
+
+  printf("Sending sync to all threads\n");
+  pthread_mutex_lock(&sync_mutex);
+  sync_var=0;
+  pthread_cond_broadcast(&sync_cond);
+  pthread_mutex_unlock(&sync_mutex);
+  // wait for end of program
+  printf("TYPE <CTRL-C> TO TERMINATE\n");
+
+
+
+#if 0
+  // test itti sim
+  usleep(10000);
+
+  protocol_ctxt_t ctxt;
+  struct rrc_gNB_ue_context_s *ue_context_p = NULL;
+
+
+  ue_context_p = rrc_gNB_allocate_new_UE_context(RC.nrrrc[0]);
+
+  if(ue_context_p == NULL){
+    printf("ue_context_p == NULL");
+  }
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
+                                0,
+                                ENB_FLAG_YES,
+                                0,
+                                0,
+                                0);
+  rrc_gNB_generate_RRCSetup(&ctxt,
+                            ue_context_p,
+                            0);
+  // end test itti sim
+#endif
+
+  printf("Entering ITTI signals handler\n");
+  itti_wait_tasks_end();
+  printf("Returned from ITTI signal handler\n");
+  oai_exit=1;
+  printf("oai_exit=%d\n",oai_exit);
+
+  printf("stopping MODEM threads\n");
+
+
+  /* release memory used by the RU/gNB threads (incomplete), after all
+   * threads have been stopped (they partially use the same memory) */
+
+  pthread_cond_destroy(&sync_cond);
+  pthread_mutex_destroy(&sync_mutex);
+
+  logClean();
+  printf("Bye.\n");
+  return 0;
+}
+
+
+