changing emulate-rf into an executional option instead of compiler option

cmake_targets/CMakeLists.txt

@@ -597,7 +597,6 @@ add_boolean_option(NAS_ADDRESS_FIX False "specific to oaisim: for nasmesh driver
 add_boolean_option(NAS_NETLINK False "???? Must be True to compile nasmesh driver without rtai")
 add_boolean_option(OAISIM False "specific to oaisim")
 add_boolean_option(OAI_NW_DRIVER_USE_NETLINK True "????")
-add_boolean_option(EMULATE_RF True "allows to run lte-softmodem without HW")
 
 add_boolean_option(USE_MME False "this flag is used only one time in lte-softmodem.c")
 add_list_string_option(PACKAGE_NAME "NotDefined" "As per attribute name")

common/utils/itti/intertask_interface.c

@@ -99,6 +99,7 @@ const int itti_debug = (ITTI_DEBUG_ISSUES | ITTI_DEBUG_MP_STATISTICS);
 # define ITTI_MEM_SIZE      (16 * 1024 * 1024)
 #endif
 
+extern int emulate_rf;
 
 typedef enum task_state_s {
   TASK_STATE_NOT_CONFIGURED, TASK_STATE_STARTING, TASK_STATE_READY, TASK_STATE_ENDED, TASK_STATE_MAX,
@@ -437,17 +438,16 @@ int itti_send_msg_to_task(task_id_t destination_task_id, instance_t instance, Me
                  destination_task_id,
                  itti_get_task_name(destination_task_id));
     } else {
-      #ifdef EMULATE_RF
-      #else
-      /* We cannot send a message if the task is not running */
-      AssertFatal (itti_desc.threads[destination_thread_id].task_state == TASK_STATE_READY,
-                   "Task %s Cannot send message %s (%d) to thread %d, it is not in ready state (%d)!\n",
-                   itti_get_task_name(origin_task_id),
-                   itti_desc.messages_info[message_id].name,
-                   message_id,
-                   destination_thread_id,
-                   itti_desc.threads[destination_thread_id].task_state);
-      #endif
+      if(!emulate_rf){
+        /* We cannot send a message if the task is not running */
+        AssertFatal (itti_desc.threads[destination_thread_id].task_state == TASK_STATE_READY,
+                     "Task %s Cannot send message %s (%d) to thread %d, it is not in ready state (%d)!\n",
+                     itti_get_task_name(origin_task_id),
+                     itti_desc.messages_info[message_id].name,
+                     message_id,
+                     destination_thread_id,
+                     itti_desc.threads[destination_thread_id].task_state);
+      }
 
       /* Allocate new list element */
       new = (message_list_t *) itti_malloc (origin_task_id, destination_task_id, sizeof(struct message_list_s));

openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c

@@ -643,6 +643,7 @@ int ulsch_decoding_data_2thread(PHY_VARS_eNB *eNB,int UE_id,int harq_pid,int llr
       break;
     }
     stop_meas(&eNB->ulsch_turbo_decoding_stats);    
+  printf("/////////////////////////////////////////**************************loop for %d time in ulsch_decoding main\n",r);
   }
 
    // wait for worker to finish

openair2/LAYER2/MAC/eNB_scheduler_phytest.c

@@ -196,13 +196,13 @@ void schedule_ulsch_phy_test(module_id_t module_idP,frame_t frameP,sub_frame_t s
   int               UE_id = 0;
   uint8_t           aggregation    = 2;
   rnti_t            rnti           = 0x1235;
-  uint8_t           mcs            = 28;
+  uint8_t           mcs            = 20;
   uint8_t           harq_pid       = 0;
   uint32_t          cqi_req = 0,cshift,ndi,tpc = 1;
   int32_t           normalized_rx_power;
   int32_t           target_rx_power= 178;
   int               CC_id = 0;
-  int               nb_rb = 20;
+  int               nb_rb = 96;
   eNB_MAC_INST      *eNB = RC.mac[module_idP];
   COMMON_channels_t *cc  = eNB->common_channels;
   UE_list_t         *UE_list=&eNB->UE_list;
@@ -236,10 +236,9 @@ void schedule_ulsch_phy_test(module_id_t module_idP,frame_t frameP,sub_frame_t s
       UE_sched_ctrl = &UE_list->UE_sched_ctrl[UE_id];
       harq_pid      = subframe2harqpid(&cc[CC_id],sched_frame,sched_subframe);
 
-      LOG_I(MAC,"Scheduling for frame %d, subframe %d => harq_pid %d\n",sched_frame,sched_subframe,harq_pid);
+      LOG_D(MAC,"Scheduling for frame %d, subframe %d => harq_pid %d\n",sched_frame,sched_subframe,harq_pid);
 
       RC.eNB[module_idP][CC_id]->pusch_stats_BO[UE_id][(frameP*10)+subframeP] = UE_template->ul_total_buffer;
-      //printf("////////////////////////////////////*************************ul_total_buffer = %d\n",UE_template->ul_total_buffer);
 
 	  
 
@@ -248,7 +247,6 @@ void schedule_ulsch_phy_test(module_id_t module_idP,frame_t frameP,sub_frame_t s
 	  
       // this is the normalized RX power and this should be constant (regardless of mcs
       normalized_rx_power = UE_sched_ctrl->pusch_snr[CC_id];
-      //printf("////////////////////////////////////*************************normalized_rx_power = %d\n",normalized_rx_power);
 	  
       // new transmission
 	  

targets/COMMON/create_tasks.c

@@ -40,6 +40,7 @@
 # endif
 # include "enb_app.h"
 
+extern int emulate_rf;
 
 int create_tasks(uint32_t enb_nb, uint32_t ue_nb)
 {
@@ -72,13 +73,12 @@ int create_tasks(uint32_t enb_nb, uint32_t ue_nb)
           LOG_E(S1AP, "Create task for S1AP failed\n");
           return -1;
         }
-        #ifdef EMULATE_RF
-        #else
-        if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
-          LOG_E(UDP_, "Create task for UDP 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;
+          }
         }
-        #endif
 
         if (itti_create_task (TASK_GTPV1_U, &gtpv1u_eNB_task, NULL) < 0) {
           LOG_E(GTPU, "Create task for GTPV1U failed\n");

targets/RT/USER/lte-enb.c

@@ -365,6 +365,10 @@ int wakeup_txfh(eNB_rxtx_proc_t *proc,RU_proc_t *ru_proc) {
   wait.tv_nsec=5000000L;
   
   
+  if (ru_proc->instance_cnt_eNBs == 0) {
+    LOG_E(PHY,"Frame %d, subframe %d: TX FH thread busy, dropping\n",proc->frame_rx,proc->subframe_rx);
+    return(-1);
+  }
   if (pthread_mutex_timedlock(&ru_proc->mutex_eNBs,&wait) != 0) {
     LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB TX1 thread %d (IC %d)\n", ru_proc->subframe_rx&1,ru_proc->instance_cnt_eNBs );
     exit_fun( "error locking mutex_eNB" );
@@ -834,6 +838,13 @@ void init_eNB_proc(int inst) {
 	attr_td     = &proc->attr_td;
 	//attr_te     = &proc->attr_te[0];
 	//attr_te1    = &proc->attr_te[1];
+    //////////////////////////////////////need to modified////////////////*****
+    if(get_nprocs() > 2 && codingw)
+    {
+      init_te_thread(eNB);
+      init_td_thread(eNB,attr_td);
+    }
+    //////////////////////////////////////need to modified////////////////*****
 	pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc );
 	pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, tx_thread, proc);
     if (eNB->single_thread_flag==0) {
@@ -854,13 +865,7 @@ void init_eNB_proc(int inst) {
 
     AssertFatal(proc->instance_cnt_prach == -1,"instance_cnt_prach = %d\n",proc->instance_cnt_prach);
 	
-	
-	//////////////////////////////////////need to modified////////////////*****
-    if(get_nprocs() > 2 && codingw)
-    {
-      init_te_thread(eNB);
-      init_td_thread(eNB,attr_td);
-    }
+
     if (opp_enabled == 1) pthread_create(&proc->process_stats_thread,NULL,process_stats_thread,(void*)eNB);
 
     

targets/RT/USER/lte-ru.c

@@ -112,6 +112,7 @@ unsigned short config_frames[4] = {2,9,11,13};
 
 
 extern volatile int                    oai_exit;
+extern int emulate_rf;
 extern int numerology;
 extern int fepw;
 
@@ -681,7 +682,6 @@ void fh_if4p5_north_out(RU_t *ru) {
   if (ru->idx == 0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_RU_FEPRX, 0 );
 }
 
-#ifdef EMULATE_RF
 static void* emulatedRF_thread(void* param) {
   RU_proc_t *proc = (RU_proc_t *) param;
   int microsec = 500; // length of time to sleep, in miliseconds
@@ -709,7 +709,6 @@ static void* emulatedRF_thread(void* param) {
   }
   return 0;
 }
-#endif
 
 void rx_rf(RU_t *ru,int *frame,int *subframe) {
 
@@ -726,17 +725,18 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
 
   old_ts = proc->timestamp_rx;
-  #ifdef EMULATE_RF
-  wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-  release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-  rxs = fp->samples_per_tti;
-  #else
-  rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
+  if(emulate_rf){
+    wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
+    release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
+    rxs = fp->samples_per_tti;
+  }
+  else{
+    rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
 				   &ts,
 				   rxp,
 				   fp->samples_per_tti,
 				   ru->nb_rx);
-  #endif
+  }
   
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
  
@@ -1434,13 +1434,12 @@ static void* ru_thread_tx( void* param ) {
   	  
     // do OFDM if needed
     if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru);
-    #ifdef EMULATE_RF
-    #else 
-    // do outgoing fronthaul (south) if needed
-    if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
-  	    
-    if (ru->fh_north_out) ru->fh_north_out(ru);
-	#endif
+    if(!emulate_rf){    
+      // do outgoing fronthaul (south) if needed
+      if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
+  	      
+      if (ru->fh_north_out) ru->fh_north_out(ru);
+	}
 
     release_thread(&proc->mutex_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx");
   }
@@ -1476,36 +1475,37 @@ static void* ru_thread( void* param ) {
 
   LOG_I(PHY,"Starting RU %d (%s,%s),\n",ru->idx,eNB_functions[ru->function],eNB_timing[ru->if_timing]);
 
-  #ifdef EMULATE_RF
-  fill_rf_config(ru,ru->rf_config_file);
-  init_frame_parms(&ru->frame_parms,1);
-  phy_init_RU(ru);
-  if (setup_RU_buffers(ru)!=0) {
-        printf("Exiting, cannot initialize RU Buffers\n");
-        exit(-1);
-  }
-  #else
-  // Start IF device if any
-  if (ru->start_if) {
-    LOG_I(PHY,"Starting IF interface for RU %d\n",ru->idx);
-    AssertFatal(ru->start_if(ru,NULL) == 0, "Could not start the IF device\n");
-    if (ru->if_south == LOCAL_RF) ret = connect_rau(ru);
-    else ret = attach_rru(ru);
-    AssertFatal(ret==0,"Cannot connect to radio\n");
-  }
-  if (ru->if_south == LOCAL_RF) { // configure RF parameters only 
-        fill_rf_config(ru,ru->rf_config_file);
-        init_frame_parms(&ru->frame_parms,1);
-        phy_init_RU(ru);
- 
-
-        ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+  if(emulate_rf){
+    fill_rf_config(ru,ru->rf_config_file);
+    init_frame_parms(&ru->frame_parms,1);
+    phy_init_RU(ru);
+    if (setup_RU_buffers(ru)!=0) {
+          printf("Exiting, cannot initialize RU Buffers\n");
+          exit(-1);
+    }
   }
-  if (setup_RU_buffers(ru)!=0) {
-        printf("Exiting, cannot initialize RU Buffers\n");
-        exit(-1);
+  else{
+    // Start IF device if any
+    if (ru->start_if) {
+      LOG_I(PHY,"Starting IF interface for RU %d\n",ru->idx);
+      AssertFatal(ru->start_if(ru,NULL) == 0, "Could not start the IF device\n");
+      if (ru->if_south == LOCAL_RF) ret = connect_rau(ru);
+      else ret = attach_rru(ru);
+      AssertFatal(ret==0,"Cannot connect to radio\n");
+    }
+    if (ru->if_south == LOCAL_RF) { // configure RF parameters only 
+          fill_rf_config(ru,ru->rf_config_file);
+          init_frame_parms(&ru->frame_parms,1);
+          phy_init_RU(ru);
+    
+    
+          ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+    }
+    if (setup_RU_buffers(ru)!=0) {
+          printf("Exiting, cannot initialize RU Buffers\n");
+          exit(-1);
+    }
   }
-  #endif
 
   LOG_I(PHY, "Signaling main thread that RU %d is ready\n",ru->idx);
   pthread_mutex_lock(&RC.ru_mutex);
@@ -1517,35 +1517,34 @@ static void* ru_thread( void* param ) {
   
 
 
-  #ifdef EMULATE_RF
-  #else
-  // Start RF device if any
-  if (ru->start_rf) {
-    if (ru->start_rf(ru) != 0)
-      LOG_E(HW,"Could not start the RF device\n");
-    else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
-  }
-  else LOG_I(PHY,"RU %d no rf device\n",ru->idx);
-
-  // if an asnych_rxtx thread exists
-  // wakeup the thread because the devices are ready at this point
- 
-  if ((ru->fh_south_asynch_in)||(ru->fh_north_asynch_in)) {
-    pthread_mutex_lock(&proc->mutex_asynch_rxtx);
-    proc->instance_cnt_asynch_rxtx=0;
-    pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
-    pthread_cond_signal(&proc->cond_asynch_rxtx);
+  if(!emulate_rf){
+    // Start RF device if any
+    if (ru->start_rf) {
+      if (ru->start_rf(ru) != 0)
+        LOG_E(HW,"Could not start the RF device\n");
+      else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
+    }
+    else LOG_I(PHY,"RU %d no rf device\n",ru->idx);
+    
+    // if an asnych_rxtx thread exists
+    // wakeup the thread because the devices are ready at this point
+    
+    if ((ru->fh_south_asynch_in)||(ru->fh_north_asynch_in)) {
+      pthread_mutex_lock(&proc->mutex_asynch_rxtx);
+      proc->instance_cnt_asynch_rxtx=0;
+      pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
+      pthread_cond_signal(&proc->cond_asynch_rxtx);
+    }
+    else LOG_I(PHY,"RU %d no asynch_south interface\n",ru->idx);
+    
+    // if this is a slave RRU, try to synchronize on the DL frequency
+    if ((ru->is_slave) && (ru->if_south == LOCAL_RF)) do_ru_synch(ru);
   }
-  else LOG_I(PHY,"RU %d no asynch_south interface\n",ru->idx);
-  
-  // if this is a slave RRU, try to synchronize on the DL frequency
-  if ((ru->is_slave) && (ru->if_south == LOCAL_RF)) do_ru_synch(ru);
 
   pthread_mutex_lock(&proc->mutex_FH1);
   proc->instance_cnt_FH1 = 0;
   pthread_mutex_unlock(&proc->mutex_FH1);
   pthread_cond_signal(&proc->cond_FH1);
-  #endif
 
 
   // This is a forever while loop, it loops over subframes which are scheduled by incoming samples from HW devices
@@ -1602,8 +1601,7 @@ static void* ru_thread( void* param ) {
     
 	if(get_nprocs() <=4)
 	{
-        #ifdef EMULATE_RF
-        #else
+      if(!emulate_rf){
         // do TX front-end processing if needed (precoding and/or IDFTs)
         if (ru->feptx_prec) ru->feptx_prec(ru);
         
@@ -1613,7 +1611,7 @@ static void* ru_thread( void* param ) {
         if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
         
         if (ru->fh_north_out) ru->fh_north_out(ru);
-        #endif
+      }
 	}
     
   }
@@ -1799,9 +1797,8 @@ void init_RU_proc(RU_t *ru) {
 #endif
   
   pthread_create( &proc->pthread_FH, attr_FH, ru_thread, (void*)ru );
-#ifdef EMULATE_RF
-  pthread_create( &proc->pthread_emulateRF, attr_emulateRF, emulatedRF_thread, (void*)proc );
-#endif
+  if(emulate_rf)
+    pthread_create( &proc->pthread_emulateRF, attr_emulateRF, emulatedRF_thread, (void*)proc );
 
   if (get_nprocs() > 4)
     pthread_create( &proc->pthread_FH1, attr_FH1, ru_thread_tx, (void*)ru );

targets/RT/USER/lte-softmodem.c

@@ -206,9 +206,10 @@ extern void reset_opp_meas(void);
 extern void print_opp_meas(void);
 
 int transmission_mode=1;
+int emulate_rf = 0;
 int numerology = 0;
-int codingw = 1;
-int fepw = 1;
+int codingw = 0;
+int fepw = 0;
 
 
 

targets/RT/USER/lte-softmodem.h

@@ -84,8 +84,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_NUMEROLOGY    "adding numerology for 5G\n"
-#define CONFIG_HLP_CODINGW       "coding worker thread disabled(enable by defult)\n"
-#define CONFIG_HLP_FEPW          "FEP worker thread disabled(enable by defult)\n"
+#define CONFIG_HLP_CODINGW       "coding worker thread enable(disable by defult)\n"
+#define CONFIG_HLP_FEPW          "FEP worker thread enabled(disable by defult)\n"
+#define CONFIG_HLP_EMULATE_RF    "Emulated RF enabled(disable by defult)\n"
 
 
 /***************************************************************************************************************************************/
@@ -170,7 +171,10 @@ extern int16_t dlsch_demod_shift;
 {"q" ,                      CONFIG_HLP_STMON,       PARAMFLAG_BOOL,         iptr:&opp_enabled,                  defintval:0,                    TYPE_INT,       0},                     \
 {"S" ,                      CONFIG_HLP_MSLOTS,      PARAMFLAG_BOOL,         u8ptr:&exit_missed_slots,           defintval:1,                    TYPE_UINT8,     0},                     \
 {"T" ,                      CONFIG_HLP_TDD,         PARAMFLAG_BOOL,         iptr:&tddflag,                      defintval:0,                    TYPE_INT,       0},                     \
-{"numerology" ,             CONFIG_HLP_NUMEROLOGY,  PARAMFLAG_BOOL,         iptr:&numerology,                   defintval:0,                    TYPE_INT,       0}                      \
+{"numerology" ,             CONFIG_HLP_NUMEROLOGY,  PARAMFLAG_BOOL,         iptr:&numerology,                   defintval:0,                    TYPE_INT,       0},                     \
+{"emulate-rf" ,             CONFIG_HLP_EMULATE_RF,  PARAMFLAG_BOOL,         iptr:&emulate_rf,                   defintval:0,                    TYPE_INT,       0},                     \
+{"codingw" ,                CONFIG_HLP_CODINGW,     PARAMFLAG_BOOL,         iptr:&codingw,                      defintval:0,                    TYPE_INT,       0},                     \
+{"fepw" ,                   CONFIG_HLP_FEPW,        PARAMFLAG_BOOL,         iptr:&fepw,                         defintval:0,                    TYPE_INT,       0}                      \
 }
 
 #define CONFIG_HLP_FLOG          "Enable online log \n"