begining functional split 6

executables/dl_fs6.c

+#define MTU 65536
+#define UDP_TIMEOUT 100000L // in nano second
+
+receiveSubFrame(int sock) {
+  //read all subframe data from the control unit
+  char * buf[MTU];
+  int ret=recv(sock, buf, sizeof(buf), 0);
+  if ( ret==-1) {
+    if ( errno == EWOULDBLOCK || errno== EINTR ) {
+      finishSubframeRecv();
+    } else {
+      LOG_E(HW,"Critical issue in socket: %s\n", strerror(errno));
+      return;
+    }
+  } else {
+  }
+      
+}
+
+void pdsch_procedures(PHY_VARS_eNB *eNB,
+                      L1_rxtx_proc_t *proc,
+                      int harq_pid,
+                      LTE_eNB_DLSCH_t *dlsch,
+                      LTE_eNB_DLSCH_t *dlsch1,
+                      LTE_eNB_UE_stats *ue_stats,
+                      int ra_flag) {
+  
+  int frame=proc->frame_tx;
+  int subframe=proc->subframe_tx;
+  LTE_DL_eNB_HARQ_t *dlsch_harq=dlsch->harq_processes[harq_pid];
+  LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
+
+  // 36-212
+  if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) { // monolthic OR PNF - do not need turbo encoding on VNF
+
+    // Replace dlsch_encoding
+    // data is in 
+    // dlsch->harq_processes[harq_pid]->e
+    feedDlschBuffers(eNB,
+                       dlsch_harq->pdu,
+                       dlsch_harq->pdsch_start,
+                       dlsch,
+                       frame,
+                       subframe,
+                       &eNB->dlsch_rate_matching_stats,
+                       &eNB->dlsch_turbo_encoding_stats,
+                       &eNB->dlsch_turbo_encoding_waiting_stats,
+                       &eNB->dlsch_turbo_encoding_main_stats,
+                       &eNB->dlsch_turbo_encoding_wakeup_stats0,
+                       &eNB->dlsch_turbo_encoding_wakeup_stats1,
+                       &eNB->dlsch_interleaving_stats);
+
+    // 36-211
+    dlsch_scrambling(fp,
+                     0,
+                     dlsch,
+                     harq_pid,
+                     get_G(fp,
+                           dlsch_harq->nb_rb,
+                           dlsch_harq->rb_alloc,
+                           dlsch_harq->Qm,
+                           dlsch_harq->Nl,
+                           dlsch_harq->pdsch_start,
+                           frame,subframe,
+                           0),
+                     0,
+                     frame,
+                     subframe<<1);
+    dlsch_modulation(eNB,
+                     eNB->common_vars.txdataF,
+                     AMP,
+                     frame,
+                     subframe,
+                     dlsch_harq->pdsch_start,
+                     dlsch,
+                     dlsch->ue_type==0 ? dlsch1 : (LTE_eNB_DLSCH_t *)NULL);
+  }
+
+  dlsch->active = 0;
+  dlsch_harq->round++;
+}
+
+phy_procedures_eNB_TX_fs6() {
+
+  receiveSubFrame();
+
+  // We got
+  // subframe number
+  //
+
+  for (aa = 0; aa < fp->nb_antenna_ports_eNB; aa++) {
+    memset (&eNB->common_vars.txdataF[aa][subframe * fp->ofdm_symbol_size * fp->symbols_per_tti],
+	    0,
+	    fp->ofdm_symbol_size * (fp->symbols_per_tti) * sizeof (int32_t));
+  }
+  
+  if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) {
+    if (is_pmch_subframe(frame,subframe,fp)) {
+      pmch_procedures(eNB,proc);
+    } else {
+      // this is not a pmch subframe, so generate PSS/SSS/PBCH
+      common_signal_procedures(eNB,proc->frame_tx, proc->subframe_tx);
+    }
+  }
+
+  if (ul_subframe < 10)if (ul_subframe < 10) { // This means that there is a potential UL subframe that will be scheduled here
+    for (i=0; i<NUMBER_OF_UE_MAX; i++) {
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+
+      if (eNB->ulsch[i] && eNB->ulsch[i]->ue_type >0) harq_pid = 0;
+      else 
+#endif
+        harq_pid = subframe2harq_pid(fp,ul_frame,ul_subframe);
+
+      if (eNB->ulsch[i]) {
+        ulsch_harq = eNB->ulsch[i]->harq_processes[harq_pid];
+        /* Store first_rb and n_DMRS for correct PHICH generation below.
+         * For PHICH generation we need "old" values of last scheduling
+         * for this HARQ process. 'generate_eNB_dlsch_params' below will
+         * overwrite first_rb and n_DMRS and 'generate_phich_top', done
+         * after 'generate_eNB_dlsch_params', would use the "new" values
+         * instead of the "old" ones.
+         *
+         * This has been tested for FDD only, may be wrong for TDD.
+         *
+         * TODO: maybe we should restructure the code to be sure it
+         *       is done correctly. The main concern is if the code
+         *       changes and first_rb and n_DMRS are modified before
+         *       we reach here, then the PHICH processing will be wrong,
+         *       using wrong first_rb and n_DMRS values to compute
+         *       ngroup_PHICH and nseq_PHICH.
+         *
+         * TODO: check if that works with TDD.
+         */
+        ulsch_harq->previous_first_rb = ulsch_harq->first_rb;
+        ulsch_harq->previous_n_DMRS = ulsch_harq->n_DMRS;
+      }
+    }
+  }
+
+  num_pdcch_symbols = eNB->pdcch_vars[subframe&1].num_pdcch_symbols;
+  num_dci           = eNB->pdcch_vars[subframe&1].num_dci;
+  if (num_dci > 0)
+    if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) {
+      generate_dci_top(num_pdcch_symbols,
+		       num_dci,
+		       &eNB->pdcch_vars[subframe&1].dci_alloc[0],
+		       0,
+		       AMP,
+		       fp,
+		       eNB->common_vars.txdataF,
+		       subframe);
+      num_mdci = eNB->mpdcch_vars[subframe &1].num_dci;
+      
+      if (num_mdci > 0) {
+	generate_mdci_top (eNB, frame, subframe, AMP, eNB->common_vars.txdataF);
+      }
+    }
+  
+  // Now scan UE specific DLSCH
+  LTE_eNB_DLSCH_t *dlsch0,*dlsch1;
+
+  for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+    dlsch0 = eNB->dlsch[(uint8_t)UE_id][0];
+    dlsch1 = eNB->dlsch[(uint8_t)UE_id][1];
+
+    if ((dlsch0)&&(dlsch0->rnti>0)&&
+        (dlsch0->active == 1)
+       ) {
+      // get harq_pid
+      harq_pid = dlsch0->harq_ids[frame%2][subframe];
+      AssertFatal(harq_pid>=0,"harq_pid is negative\n");
+
+      if (harq_pid>=8) {
+        if (dlsch0->ue_type==0)
+          LOG_E(PHY,"harq_pid:%d corrupt must be 0-7 UE_id:%d frame:%d subframe:%d rnti:%x \n",
+		harq_pid,UE_id,frame,subframe,dlsch0->rnti);
+      } else {
+        // generate pdsch
+        pdsch_procedures_fs6(eNB,
+			     proc,
+			     harq_pid,
+			     dlsch0,
+			     dlsch1,
+			     &eNB->UE_stats[(uint32_t)UE_id],
+			     0);
+      }
+    } else if ((dlsch0)&&(dlsch0->rnti>0)&&
+               (dlsch0->active == 0)
+              ) {
+      // clear subframe TX flag since UE is not scheduled for PDSCH in this subframe (so that we don't look for PUCCH later)
+      dlsch0->subframe_tx[subframe]=0;
+    }
+  }
+  generate_phich_top(eNB,
+                     proc,
+                     AMP);
+
+}
+
+DL_thread_fs6() {
+  receiveSubFrame();
+  phy_procedures_eNB_TX_fs6();
+  ru->feptx_prec(ru);
+  ru->feptx_ofdm(ru);
+  ru->fh_south_out(ru);
+}
+
+int createListner (port) {
+  int sock;
+  AssertFatal((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) >= 0, "");
+    struct sockaddr_in addr = {
+sin_family:
+    AF_INET,
+sin_port:
+htons(port),
+sin_addr:
+    { s_addr: INADDR_ANY }
+  };
+ AssertFatal(bind(sock, const struct sockaddr *addr, socklen_t addrlen)==0,"");
+ struct timeval tv={0,UDP_TIMEOUT};
+ AssertFatal(setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,&tv,sizeof(tv)) ==0,"");
+}
+
+
+DL_thread_frequency() {
+  frequency_t header;
+  
+  full_read(&header, 

executables/split_headers.h

+#ifndef __SPLIT_HEADERS_H
+#define __SPLIT_HEADERS_H
+
+struct frequency_s {
+  int frame;
+  int subframe;
+  int timestamp;
+  int sampleSize;
+  int nbAnt
+  int nbSamples;
+} frequency_t;
+  
+#endif

openair1/SIMULATION/LTE_PHY/ulsim.c

@@ -1354,7 +1354,7 @@ int main(int argc, char **argv) {
         printStatIndent2(&eNB->ulsch_deinterleaving_stats,"sub-block interleaving" );
         printStatIndent2(&eNB->ulsch_demultiplexing_stats,"sub-block demultiplexing" );
         printStatIndent2(&eNB->ulsch_rate_unmatching_stats,"sub-block rate-matching" );
-        printf("|__ turbo_decoder(%d bits), avg iterations: %.1f       %.2f us (%d cycles, %d trials)\n",
+        printf("    |__ turbo_decoder(%d bits), avg iterations: %.1f       %.2f us (%d cycles, %d trials)\n",
                eNB->ulsch[0]->harq_processes[harq_pid]->Cminus ?
                eNB->ulsch[0]->harq_processes[harq_pid]->Kminus :
                eNB->ulsch[0]->harq_processes[harq_pid]->Kplus,

targets/ARCH/COMMON/common_lib.c

@@ -105,7 +105,7 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
   if ( IS_SOFTMODEM_BASICSIM ) {
     libname=OAI_BASICSIM_LIBNAME;
     shlib_fdesc[0].fname="device_init";
-  } else if ( IS_SOFTMODEM_RFSIM ) {
+  } else if ( IS_SOFTMODEM_RFSIM && flag == RAU_LOCAL_RADIO_HEAD) {
     libname=OAI_RFSIM_LIBNAME;
     shlib_fdesc[0].fname="device_init";
   } else if (flag == RAU_LOCAL_RADIO_HEAD) {

targets/ARCH/COMMON/common_lib.h

@@ -102,6 +102,10 @@ typedef enum {
   IRIS_DEV,
   /*!\brief device is NONE*/
   NONE_DEV,
+  /*!\brief device is ADRV9371_ZC706 */
+  ADRV9371_ZC706_DEV,
+  /*!\brief device is UEDv2 */
+  UEDv2_DEV,
   MAX_RF_DEV_TYPE
 
 } dev_type_t;
@@ -214,6 +218,14 @@ typedef struct {
   int iq_rxrescale;
   //! Configuration file for LMS7002M
   char *configFilename;
+  //! remote IP/MAC addr for Ethernet interface
+  char *remote_addr;
+  //! remote port number for Ethernet interface
+  unsigned int remote_port;
+  //! local IP/MAC addr for Ethernet interface (eNB/BBU, UE)
+  char *my_addr;
+  //! local port number for Ethernet interface (eNB/BBU, UE)
+  unsigned int my_port;
 #if defined(USRP_REC_PLAY)
   unsigned short sf_mode;           // 1=record, 2=replay
   char           sf_filename[1024]; // subframes file path
@@ -223,6 +235,13 @@ typedef struct {
   unsigned int   sf_write_delay;    // write delay in replay mode
   unsigned int   eth_mtu;           // ethernet MTU
 #endif
+
+  //! number of samples per tti
+  unsigned int  samples_per_tti;
+  //! the sample rate for receive.
+  double rx_sample_rate;
+  //! the sample rate for transmit.
+  double tx_sample_rate;
 } openair0_config_t;
 
 /*! \brief RF mapping */
@@ -384,6 +403,31 @@ struct openair0_device_t {
 typedef int(*oai_device_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg);
 /* type of transport init function, implemented in shared lib */
 typedef int(*oai_transport_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
+#define UE_MAGICDL_FDD 0xA5A5A5A5A5A5A5A5  // UE DL FDD record
+#define UE_MAGICUL_FDD 0x5A5A5A5A5A5A5A5A  // UE UL FDD record
+#define UE_MAGICDL_TDD 0xA6A6A6A6A6A6A6A6  // UE DL TDD record
+#define UE_MAGICUL_TDD 0x6A6A6A6A6A6A6A6A  // UE UL TDD record
+
+#define ENB_MAGICDL_FDD 0xB5B5B5B5B5B5B5B5  // eNB DL FDD record
+#define ENB_MAGICUL_FDD 0x5B5B5B5B5B5B5B5B  // eNB UL FDD record
+#define ENB_MAGICDL_TDD 0xB6B6B6B6B6B6B6B6  // eNB DL TDD record
+#define ENB_MAGICUL_TDD 0x6B6B6B6B6B6B6B6B  // eNB UL TDD record
+
+#define OPTION_LZ4  0x00000001          // LZ4 compression (option_value is set to compressed size)
+
+#define sample_t uint32_t // 2*16 bits complex number
+
+typedef struct {
+  uint64_t magic;          // Magic value (see defines above)
+  uint32_t size;           // Number of samples per antenna to follow this header
+  uint32_t nbAnt;          // Total number of antennas following this header
+  // Samples per antenna follow this header,
+  // i.e. nbAnt = 2 => this header+samples_antenna_0+samples_antenna_1
+  // data following this header in bytes is nbAnt*size*sizeof(sample_t)
+  uint64_t timestamp;      // Timestamp value of first sample
+  uint32_t option_value;   // Option value
+  uint32_t option_flag;    // Option flag
+} samplesBlockHeader_t;
 
 #ifdef __cplusplus
 extern "C"
@@ -408,7 +452,7 @@ openair0_timestamp get_usrp_time(openair0_device *device);
  * \returns 0 in success
  */
 int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *openair0_cfg);
-
+#define gettid() syscall(__NR_gettid)
 /*@}*/
 
 #ifdef __cplusplus

targets/RT/USER/lte-ru.c

@@ -148,7 +148,7 @@ int attach_rru(RU_t *ru) {
   RRU_CONFIG_msg_t rru_config_msg;
   int received_capabilities=0;
   wait_eNBs();
-
+  LOG_ENTER(PHY);
   // Wait for capabilities
   while (received_capabilities==0) {
     memset((void *)&rru_config_msg,0,sizeof(rru_config_msg));
@@ -208,7 +208,7 @@ int connect_rau(RU_t *ru) {
   RRU_capabilities_t *cap;
   int                i;
   int                len;
-
+  LOG_ENTER(PHY);
   // wait for RAU_tick
   while (tick_received == 0) {
     msg_len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE;
@@ -299,7 +299,7 @@ int connect_rau(RU_t *ru) {
 // southbound IF5 fronthaul for 16-bit OAI format
 static inline void fh_if5_south_out(RU_t *ru) {
   if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
-
+  LOG_ENTER(PHY);
   send_IF5(ru, ru->proc.timestamp_tx, ru->proc.subframe_tx, &ru->seqno, IF5_RRH_GW_DL);
 }
 
@@ -315,7 +315,7 @@ static inline void fh_if4p5_south_out(RU_t *ru) {
   if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
 
   LOG_D(PHY,"Sending IF4p5 for frame %d subframe %d\n",ru->proc.frame_tx,ru->proc.subframe_tx);
-
+  LOG_ENTER(PHY);
   if (subframe_select(&ru->frame_parms,ru->proc.subframe_tx)!=SF_UL)
     send_IF4p5(ru,ru->proc.frame_tx, ru->proc.subframe_tx, IF4p5_PDLFFT);
 }
@@ -327,6 +327,7 @@ static inline void fh_if4p5_south_out(RU_t *ru) {
 void fh_if5_south_in(RU_t *ru,int *frame, int *subframe) {
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
   RU_proc_t *proc = &ru->proc;
+    LOG_ENTER(PHY);
   recv_IF5(ru, &proc->timestamp_rx, *subframe, IF5_RRH_GW_UL);
   proc->frame_rx    = (proc->timestamp_rx / (fp->samples_per_tti*10))&1023;
   proc->subframe_rx = (proc->timestamp_rx / fp->samples_per_tti)%10;
@@ -358,14 +359,14 @@ void fh_if4p5_south_in(RU_t *ru,int *frame,int *subframe) {
   uint16_t packet_type;
   uint32_t symbol_number=0;
   uint32_t symbol_mask_full;
-
+  LOG_ENTER(PHY);
   if ((fp->frame_type == TDD) && (subframe_select(fp,*subframe)==SF_S))
     symbol_mask_full = (1<<fp->ul_symbols_in_S_subframe)-1;
   else
     symbol_mask_full = (1<<fp->symbols_per_tti)-1;
 
   AssertFatal(proc->symbol_mask[*subframe]==0,"rx_fh_if4p5: proc->symbol_mask[%d] = %x\n",*subframe,proc->symbol_mask[*subframe]);
-
+  LOG_D(PHY,"start rcv IF4p5 \n");
   do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
     recv_IF4p5(ru, &f, &sf, &packet_type, &symbol_number);
 
@@ -382,6 +383,7 @@ void fh_if4p5_south_in(RU_t *ru,int *frame,int *subframe) {
 
     LOG_D(PHY,"rx_fh_if4p5: subframe %d symbol mask %x\n",*subframe,proc->symbol_mask[*subframe]);
   } while(proc->symbol_mask[*subframe] != symbol_mask_full);
+  LOG_D(PHY,"Done rcv IF4p5 \n");
 
   //caculate timestamp_rx, timestamp_tx based on frame and subframe
   proc->subframe_rx  = sf;
@@ -482,6 +484,7 @@ void fh_if4p5_south_asynch_in(RU_t *ru,int *frame,int *subframe) {
   symbol_mask   = (1<<fp->symbols_per_tti)-1;
   prach_rx      = 0;
 
+    LOG_D(PHY,"start rcv IF4p5 \n");
   do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
     recv_IF4p5(ru, &proc->frame_rx, &proc->subframe_rx, &packet_type, &symbol_number);
 
@@ -578,6 +581,7 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
   uint16_t packet_type;
   uint32_t symbol_number,symbol_mask,symbol_mask_full;
   int subframe_tx,frame_tx;
+  LOG_ENTER(PHY);
   LOG_D(PHY, "%s(ru:%p frame, subframe)\n", __FUNCTION__, ru);
   symbol_number = 0;
   symbol_mask = 0;
@@ -643,7 +647,7 @@ void fh_if4p5_north_out(RU_t *ru) {
   RU_proc_t *proc=&ru->proc;
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
   const int subframe     = proc->subframe_rx;
-
+  LOG_ENTER(PHY);
   if (ru->idx==0) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_RU, proc->subframe_rx );
 
   if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) {
@@ -712,6 +716,8 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
   unsigned int rxs;
   int i;
   openair0_timestamp ts=0,old_ts=0;
+  LOG_ENTER(PHY);
+  LOG_D(PHY,"%s:%d start rx_rf \n", __FILE__,__LINE__);
 
   for (i=0; i<ru->nb_rx; i++)
     rxp[i] = (void *)&ru->common.rxdata[i][*subframe*fp->samples_per_tti];
@@ -820,6 +826,7 @@ void tx_rf(RU_t *ru) {
   lte_subframe_t SF_type     = subframe_select(fp,proc->subframe_tx%10);
   lte_subframe_t prevSF_type = subframe_select(fp,(proc->subframe_tx+9)%10);
   int sf_extension = 0;
+  LOG_D(PHY,"start tx_rf \n");
 
   if ((SF_type == SF_DL) ||
       (SF_type == SF_S)) {
@@ -935,6 +942,7 @@ static void *ru_thread_asynch_rxtx( void *param ) {
   printf( "devices ok (ru_thread_asynch_rx)\n");
 
   while (!oai_exit) {
+      LOG_ENTER(PHY);
     if (oai_exit) break;
 
     if (subframe==9) {
@@ -968,7 +976,7 @@ void wakeup_slaves(RU_proc_t *proc) {
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
-
+  LOG_ENTER(PHY);
   for (i=0; i<proc->num_slaves; i++) {
     RU_proc_t *slave_proc = proc->slave_proc[i];
 
@@ -1029,7 +1037,7 @@ static void *ru_thread_prach( void *param ) {
     if (oai_exit) break;
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_RU_PRACH_RX, 1 );
-
+  LOG_ENTER(PHY);
     if (ru->eNB_list[0]) {
       prach_procedures(
         ru->eNB_list[0]
@@ -1075,7 +1083,7 @@ static void *ru_thread_prach_br( void *param ) {
     if (wait_on_condition(&proc->mutex_prach_br,&proc->cond_prach_br,&proc->instance_cnt_prach_br,"ru_prach_thread_br") < 0) break;
 
     if (oai_exit) break;
-
+  LOG_ENTER(PHY);
     rx_prach(NULL,
              ru,
              NULL,
@@ -1098,7 +1106,7 @@ int wakeup_synch(RU_t *ru) {
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
-
+  LOG_ENTER(PHY);
   // wake up synch thread
   // lock the synch mutex and make sure the thread is ready
   if (pthread_mutex_timedlock(&ru->proc.mutex_synch,&wait) != 0) {
@@ -1135,7 +1143,7 @@ void do_ru_synch(RU_t *ru) {
 
   double temp_freq1 = ru->rfdevice.openair0_cfg->rx_freq[0];
   double temp_freq2 = ru->rfdevice.openair0_cfg->tx_freq[0];
-
+  LOG_ENTER(PHY);
   for (i=0; i<4; i++) {
     ru->rfdevice.openair0_cfg->rx_freq[i] = ru->rfdevice.openair0_cfg->tx_freq[i];
     ru->rfdevice.openair0_cfg->tx_freq[i] = temp_freq1;
@@ -1198,7 +1206,7 @@ void wakeup_L1s(RU_t *ru) {
   int i;
   PHY_VARS_eNB **eNB_list = ru->eNB_list;
   LOG_D(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top);
-
+  LOG_ENTER(PHY);
   if (ru->num_eNB==1 && ru->eNB_top!=0 && get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD) {
     // call eNB function directly
     char string[20];
@@ -1496,7 +1504,7 @@ static void *ru_thread_tx( void *param ) {
     wait_on_condition(&proc->mutex_eNBs,&proc->cond_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx");
 
     if (oai_exit) break;
-
+  LOG_ENTER(PHY);
     // do TX front-end processing if needed (precoding and/or IDFTs)
     if (ru->feptx_prec) ru->feptx_prec(ru);
 
@@ -1644,7 +1652,7 @@ static void *ru_thread( void *param ) {
   // This is a forever while loop, it loops over subframes which are scheduled by incoming samples from HW devices
   while (!oai_exit) {
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_CPUID_RU_THREAD,sched_getcpu());
-
+  LOG_ENTER(PHY);
     // these are local subframe/frame counters to check that we are in synch with the fronthaul timing.
     // They are set on the first rx/tx in the underly FH routines.
     if (subframe==9) {