From cedde4ad1ff3a37372ffbd8df821b8d6a7f870e1 Mon Sep 17 00:00:00 2001
From: laurent <laurent.thomas@free.fr>
Date: Mon, 26 Dec 2016 21:19:26 +0100
Subject: [PATCH] realtime for UE

---
 common/utils/itti/assertions.h               |    2 +-
 openair1/PHY/defs.h                          |    3 +
 openair2/COMMON/platform_types.h             |    2 +-
 openair2/UTIL/LOG/log.h                      |   20 +
 targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp |  981 +++----
 targets/RT/USER/lte-ue.c                     | 2391 +++++++-----------
 6 files changed, 1324 insertions(+), 2075 deletions(-)

diff --git a/common/utils/itti/assertions.h b/common/utils/itti/assertions.h
index df8251d105..a411bd5397 100644
--- a/common/utils/itti/assertions.h
+++ b/common/utils/itti/assertions.h
@@ -65,7 +65,7 @@ _Assert_(cOND, _Assert_Exit_, #vALUE1 ": %" PRIdMAX "\n" #vALUE2 ": %" PRIdMAX "
          (intmax_t)vALUE1, (intmax_t)vALUE2, (intmax_t)vALUE3)
 
 #define DevCheck4(cOND, vALUE1, vALUE2, vALUE3, vALUE4)                                                                         \
-_Assert_(cOND, _Assert_Exit_, #vALUE1": %"PRIdMAX"\n"#vALUE2": %"PRIdMAX"\n"#vALUE3": %"PRIdMAX"\n"#vALUE4": %"PRIdMAX"\n\n",   \
+_Assert_(cOND, _Assert_Exit_, #vALUE1": %" PRIdMAX "\n" #vALUE2 ": %" PRIdMAX "\n" #vALUE3 ": %" PRIdMAX "\n" #vALUE4 ": %" PRIdMAX "\n\n",   \
          (intmax_t)vALUE1, (intmax_t)vALUE2, (intmax_t)vALUE3, (intmax_t)vALUE4)
 
 #define DevParam(vALUE1, vALUE2, vALUE3)    DevCheck(0, vALUE1, vALUE2, vALUE3)
diff --git a/openair1/PHY/defs.h b/openair1/PHY/defs.h
index daf560a736..9c72bc433e 100644
--- a/openair1/PHY/defs.h
+++ b/openair1/PHY/defs.h
@@ -371,6 +371,9 @@ typedef struct {
   pthread_mutex_t mutex_rxtx;
   /// scheduling parameters for RXn-TXnp4 thread
   struct sched_param sched_param_rxtx;
+  int sub_frame_start;
+  int sub_frame_step;
+  unsigned long long gotIQs;
 } UE_rxtx_proc_t;
 
 /// Context data structure for eNB subframe processing
diff --git a/openair2/COMMON/platform_types.h b/openair2/COMMON/platform_types.h
index 327523f1d0..256ed45b5d 100644
--- a/openair2/COMMON/platform_types.h
+++ b/openair2/COMMON/platform_types.h
@@ -255,7 +255,7 @@ typedef struct protocol_ctxt_s {
     (Ctxt_Pp)->subframe  = sUBfRAME; \
     PROTOCOL_CTXT_COMPUTE_MODULE_ID(Ctxt_Pp)
 
-#define PROTOCOL_CTXT_FMT "[FRAME %05u][%s][MOD %02u][RNTI %"PRIx16"]"
+#define PROTOCOL_CTXT_FMT "[FRAME %05u][%s][MOD %02u][RNTI %" PRIx16 "]"
 #define PROTOCOL_CTXT_ARGS(CTXT_Pp) \
     (CTXT_Pp)->frame, \
     ((CTXT_Pp)->enb_flag == ENB_FLAG_YES) ? "eNB":" UE", \
diff --git a/openair2/UTIL/LOG/log.h b/openair2/UTIL/LOG/log.h
index 6a6569c1a5..171f74da41 100644
--- a/openair2/UTIL/LOG/log.h
+++ b/openair2/UTIL/LOG/log.h
@@ -53,6 +53,26 @@
 extern "C" {
 #endif
 
+  extern double cpuf;
+  static inline unsigned long long rdtsc(void) {
+    unsigned long long a, d;
+    __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
+    return (d<<32) | a;
+  }
+  static inline unsigned long long checkT(int timeout, char * file, int line) {
+    static unsigned long long __thread last=0;
+    unsigned long long cur=rdtsc();
+    int microCycles=(int)(cpuf*1000);
+    int duration=(int)((cur-last)/microCycles);
+    if ( last!=0 && duration > timeout )
+      printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
+	     duration, timeout);
+    last=cur;
+    return cur;
+  }
+
+#define check(a) checkT(a,__FILE__,__LINE__)
+  
 /** @defgroup _LOG LOG Generator
  * @{*/
 /* @}*/
diff --git a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
index 0161761d97..3185b97226 100644
--- a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
+++ b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
@@ -40,10 +40,12 @@
 #include <time.h>
 #include "UTIL/LOG/log_extern.h"
 #include "common_lib.h"
+#include "assertions.h"
+
 #ifdef __SSE4_1__
 #  include <smmintrin.h>
 #endif
- 
+
 #ifdef __AVX2__
 #  include <immintrin.h>
 #endif
@@ -56,16 +58,14 @@
  * @{
  */
 
-/*! \brief USRP Configuration */ 
-typedef struct
-{
+/*! \brief USRP Configuration */
+typedef struct {
 
-  // --------------------------------
-  // variables for USRP configuration
-  // --------------------------------
-  //! USRP device pointer
-  uhd::usrp::multi_usrp::sptr usrp;
-  //uhd::usrp::multi_usrp::sptr rx_usrp;
+    // --------------------------------
+    // variables for USRP configuration
+    // --------------------------------
+    //! USRP device pointer
+    uhd::usrp::multi_usrp::sptr usrp;
   
   //create a send streamer and a receive streamer
   //! USRP TX Stream
@@ -78,141 +78,93 @@ typedef struct
   //! USRP RX Metadata
   uhd::rx_metadata_t rx_md;
 
-  //! USRP Timestamp Information
-  uhd::time_spec_t tm_spec;
-
-  //setup variables and allocate buffer
-  //! USRP Metadata
-  uhd::async_metadata_t async_md;
+    //! Sampling rate
+    double sample_rate;
 
-  //! Sampling rate
-  double sample_rate;
+    //! TX forward samples. We use usrp_time_offset to get this value
+    int tx_forward_nsamps; //166 for 20Mhz
 
-  //! time offset between transmiter timestamp and receiver timestamp;
-  double tdiff;
-
-  //! TX forward samples. We use usrp_time_offset to get this value
-  int tx_forward_nsamps; //166 for 20Mhz
+    // --------------------------------
+    // Debug and output control
+    // --------------------------------
+    int num_underflows;
+    int num_overflows;
+    int num_seq_errors;
+    int64_t tx_count;
+    int64_t rx_count;
+    //! timestamp of RX packet
+    openair0_timestamp rx_timestamp;
 
+} usrp_state_t;
 
-  // --------------------------------
-  // Debug and output control
-  // --------------------------------
-  //! Number of underflows
-  int num_underflows;
-  //! Number of overflows
-  int num_overflows;
-  
-  //! Number of sequential errors
-  int num_seq_errors;
-  //! tx count
-  int64_t tx_count;
-  //! rx count
-  int64_t rx_count;
-  //! timestamp of RX packet
-  openair0_timestamp rx_timestamp;
 
-} usrp_state_t;
 
 /*! \brief Called to start the USRP transceiver. Return 0 if OK, < 0 if error
     @param device pointer to the device structure specific to the RF hardware target
 */
-static int trx_usrp_start(openair0_device *device)
-{
-  usrp_state_t *s = (usrp_state_t*)device->priv;
+static int trx_usrp_start(openair0_device *device) {
 
-  // init recv and send streaming
-  uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
-  cmd.time_spec = s->usrp->get_time_now() + uhd::time_spec_t(0.05);
-  cmd.stream_now = false; // start at constant delay
-  s->rx_stream->issue_stream_cmd(cmd);
+    usrp_state_t *s = (usrp_state_t*)device->priv;
 
-  s->tx_md.time_spec = cmd.time_spec + uhd::time_spec_t(1-(double)s->tx_forward_nsamps/s->sample_rate);
-  s->tx_md.has_time_spec = true;
-  s->tx_md.start_of_burst = true;
-  s->tx_md.end_of_burst = false;
+    // init recv and send streaming
+    uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+    cmd.time_spec = s->usrp->get_time_now() + uhd::time_spec_t(0.05);
+    cmd.stream_now = true;
+    s->rx_stream->issue_stream_cmd(cmd);
 
+    s->tx_md.time_spec = cmd.time_spec + uhd::time_spec_t(1-(double)s->tx_forward_nsamps/s->sample_rate);
+    s->tx_md.has_time_spec = true;
+    s->tx_md.start_of_burst = true;
+    s->tx_md.end_of_burst = false;
 
-  s->rx_count = 0;
-  s->tx_count = 0;
-  s->rx_timestamp = 0;
-
-  return 0;
+    s->rx_count = 0;
+    s->tx_count = 0;
+    s->rx_timestamp = 0;
+    return 0;
 }
 /*! \brief Terminate operation of the USRP transceiver -- free all associated resources 
  * \param device the hardware to use
  */
-static void trx_usrp_end(openair0_device *device)
-{
-  usrp_state_t *s = (usrp_state_t*)device->priv;
+static void trx_usrp_end(openair0_device *device) {
+    usrp_state_t *s = (usrp_state_t*)device->priv;
 
-  s->rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+    s->rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+    //send a mini EOB packet
+    s->tx_md.end_of_burst = true;
+    s->tx_stream->send("", 0, s->tx_md);
+    s->tx_md.end_of_burst = false;
 
-  //send a mini EOB packet
-  s->tx_md.end_of_burst = true;
-  s->tx_stream->send("", 0, s->tx_md);
-  s->tx_md.end_of_burst = false;
-  
 }
 
 /*! \brief Called to send samples to the USRP RF target
       @param device pointer to the device structure specific to the RF hardware target
-      @param timestamp The timestamp at whicch the first sample MUST be sent 
+      @param timestamp The timestamp at whicch the first sample MUST be sent
       @param buff Buffer which holds the samples
       @param nsamps number of samples to be sent
       @param antenna_id index of the antenna if the device has multiple anteannas
       @param flags flags must be set to TRUE if timestamp parameter needs to be applied
-*/ 
-static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
-{
-   static long long int loop=0;
-   static long time_min=0, time_max=0, time_avg=0;
-   struct timespec tp_start, tp_end;
-   long time_diff;
-   clock_gettime(CLOCK_MONOTONIC_RAW, &tp_start);
-
-  int ret=0, ret_i=0;
-  usrp_state_t *s = (usrp_state_t*)device->priv;
+*/
+static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
+    int ret=0;
+    usrp_state_t *s = (usrp_state_t*)device->priv;
 
-  s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
+    s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
+    s->tx_md.has_time_spec = flags;
 
-  
-  if(flags)
-    s->tx_md.has_time_spec = true;
-  else
-    s->tx_md.has_time_spec = false;
-  
-  if (cc>1) {
-    std::vector<void *> buff_ptrs;
-    for (int i=0;i<cc;i++) buff_ptrs.push_back(buff[i]);
-    ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md,1e-3);
-  }
-  else
-    ret = (int)s->tx_stream->send(buff[0], nsamps, s->tx_md,1e-3);
+    if (cc>1) {
+        std::vector<void *> buff_ptrs;
+        for (int i=0; i<cc; i++)
+            buff_ptrs.push_back(buff[i]);
+        ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md,1e-3);
+    } else
+        ret = (int)s->tx_stream->send(buff[0], nsamps, s->tx_md,1e-3);
 
-  s->tx_md.start_of_burst = false;
+    s->tx_md.start_of_burst = false;
 
-  if (ret != nsamps) {
-    printf("[xmit] tx samples %d != %d\n",ret,nsamps);
-  }
+    if (ret != nsamps)
+        LOG_E(PHY,"[xmit] tx samples %d != %d\n",ret,nsamps);
 
-  clock_gettime(CLOCK_MONOTONIC_RAW, &tp_end);
-  time_diff = (tp_end.tv_sec - tp_start.tv_sec) *1E09  + (tp_end.tv_nsec - tp_start.tv_nsec);
-  if  (time_min==0 ||loop==1 || time_min > time_diff)
-    time_min=time_diff;
-  if  (time_max==0 ||loop==1 || time_max < time_diff)
-    time_max=time_diff;
-  if (time_avg ==0 ||loop==1)
-    time_avg= time_diff;
-  else
-    time_avg=(time_diff+time_avg) /2.0;
-
-  /*   //prints statics of uhd every 10 seconds
-   if ( loop % (10 * ((int)device->openair0_cfg[0].sample_rate /(int)nsamps )) ==0)
-     LOG_I(HW,"usrp_write: min(ns)=%d, max(ns)=%d, avg(ns)=%d\n", (int)time_min, (int)time_max,(int)time_avg);
-  */
-   loop++;
-  return ret;
+    return ret;
 }
 
 /*! \brief Receive samples from hardware.
@@ -226,45 +178,42 @@ static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp,
  * \param antenna_id Index of antenna for which to receive samples
  * \returns the number of sample read
 */
-static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc)
-{
-   static long long int loop=0;
-   static long time_min=0, time_max=0, time_avg=0;
-   struct timespec tp_start, tp_end;
-   long time_diff;
-   clock_gettime(CLOCK_MONOTONIC_RAW, &tp_start);
-   usrp_state_t *s = (usrp_state_t*)device->priv;
-   int samples_received=0,i,j;
-   int nsamps2;  // aligned to upper 32 or 16 byte boundary
+static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
+    usrp_state_t *s = (usrp_state_t*)device->priv;
+    int samples_received=0,i,j;
+    int nsamps2;  // aligned to upper 32 or 16 byte boundary
 #if defined(__x86_64) || defined(__i386__)
 #ifdef __AVX2__
-   nsamps2 = (nsamps+7)>>3;
-   __m256i buff_tmp[2][nsamps2];
+    nsamps2 = (nsamps+7)>>3;
+    __m256i buff_tmp[2][nsamps2];
 #else
-   nsamps2 = (nsamps+3)>>2;
-   __m128i buff_tmp[2][nsamps2];
+    nsamps2 = (nsamps+3)>>2;
+    __m128i buff_tmp[2][nsamps2];
 #endif
 #elif defined(__arm__)
-   nsamps2 = (nsamps+3)>>2;
-   int16x8_t buff_tmp[2][nsamps2];
+    nsamps2 = (nsamps+3)>>2;
+    int16x8_t buff_tmp[2][nsamps2];
 #endif
 
-
-  if (device->type == USRP_B200_DEV) {  
-    if (cc>1) {
-    // receive multiple channels (e.g. RF A and RF B)
-      std::vector<void *> buff_ptrs;
- 
-      for (int i=0;i<cc;i++) buff_ptrs.push_back(buff_tmp[i]);
-      samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
-    } else {
-    // receive a single channel (e.g. from connector RF A)
-      samples_received = s->rx_stream->recv(buff_tmp[0], nsamps, s->rx_md);
-    }
-
-  // bring RX data into 12 LSBs for softmodem RX
-    for (int i=0;i<cc;i++) {
-      for (int j=0; j<nsamps2; j++) {      
+    if (device->type == USRP_B200_DEV) {
+        if (cc>1) {
+            // receive multiple channels (e.g. RF A and RF B)
+            std::vector<void *> buff_ptrs;
+            for (int i=0; i<cc; i++) buff_ptrs.push_back(buff_tmp[i]);
+            samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
+        } else {
+            // receive a single channel (e.g. from connector RF A)
+            samples_received=0;
+            while (samples_received != nsamps) {
+                samples_received += s->rx_stream->recv(buff_tmp[0]+samples_received,
+                                                       nsamps-samples_received, s->rx_md);
+                if (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE)
+                    break;
+            }
+        }
+        // bring RX data into 12 LSBs for softmodem RX
+        for (int i=0; i<cc; i++) {
+            for (int j=0; j<nsamps2; j++) {
 #if defined(__x86_64__) || defined(__i386__)
 #ifdef __AVX2__
         ((__m256i *)buff[i])[j] = _mm256_srai_epi16(buff_tmp[i][j],4);
@@ -288,67 +237,26 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
       samples_received = s->rx_stream->recv(buff[0], nsamps, s->rx_md);
     }
   }
+    if (samples_received < nsamps)
+        LOG_E(PHY,"[recv] received %d samples out of %d\n",samples_received,nsamps);
 
-  if (samples_received < nsamps) {
-    printf("[recv] received %d samples out of %d\n",samples_received,nsamps);
-    
-  }
+    if ( s->rx_md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE)
+        LOG_E(PHY,s->rx_md.to_pp_string(true).c_str());
 
-  //handle the error code
-  switch(s->rx_md.error_code){
-  case uhd::rx_metadata_t::ERROR_CODE_NONE:
-    break;
-  case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
-    printf("[recv] USRP RX OVERFLOW!\n");
-    s->num_overflows++;
-    break;
-  case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
-    printf("[recv] USRP RX TIMEOUT!\n");
-    break;
-  default:
-    printf("[recv] Unexpected error on RX, Error code: 0x%x\n",s->rx_md.error_code);
-    break;
-  }
-  s->rx_count += nsamps;
-  s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
-  *ptimestamp = s->rx_timestamp;
-
-  clock_gettime(CLOCK_MONOTONIC_RAW, &tp_end);
-  time_diff = (tp_end.tv_sec - tp_start.tv_sec) *1E09  + (tp_end.tv_nsec - tp_start.tv_nsec);
-  if  (time_min==0 ||loop==1 || time_min > time_diff)
-    time_min=time_diff;
-  if  (time_max==0 ||loop==1 || time_max < time_diff)
-    time_max=time_diff;
-  if (time_avg ==0 ||loop==1)
-    time_avg= time_diff;
-  else
-    time_avg=(time_diff+time_avg) /2.0;
-  /*
-  //prints statics of uhd every 10 seconds
-  if ( loop % (10 * ((int)device->openair0_cfg[0].sample_rate /(int)nsamps )) ==0)
-     LOG_I(HW,"usrp_read: min(ns)=%d, max(ns)=%d, avg(ns)=%d\n", (int)time_min, (int)time_max,(int)time_avg);
-
-     loop++;*/
-  return samples_received;
+    s->rx_count += nsamps;
+    s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
+    *ptimestamp = s->rx_timestamp;
+#ifdef DEBUG_USRP
+    check(50);
+#endif
+    return samples_received;
 }
 
-/*! \brief Get current timestamp of USRP
- * \param device the hardware to use
-*/
-openair0_timestamp get_usrp_time(openair0_device *device) 
-{
- 
-  usrp_state_t *s = (usrp_state_t*)device->priv;
-  
-  return s->usrp->get_time_now().to_ticks(s->sample_rate);
-} 
-
 /*! \brief Compares two variables within precision
  * \param a first variable
  * \param b second variable
 */
-static bool is_equal(double a, double b)
-{
+static bool is_equal(double a, double b) {
   return std::fabs(a-b) < std::numeric_limits<double>::epsilon();
 }
 
@@ -360,59 +268,60 @@ static bool is_equal(double a, double b)
  */
 int trx_usrp_set_freq(openair0_device* device, openair0_config_t *openair0_cfg, int dummy) {
 
-  usrp_state_t *s = (usrp_state_t*)device->priv;
+    usrp_state_t *s = (usrp_state_t*)device->priv;
 
-  printf("Setting USRP TX Freq %f, RX Freq %f\n",openair0_cfg[0].tx_freq[0],openair0_cfg[0].rx_freq[0]);
-  s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[0]);
-  s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[0]);
+    LOG_I(PHY,"Setting USRP TX Freq %f, RX Freq %f\n",openair0_cfg[0].tx_freq[0],openair0_cfg[0].rx_freq[0]);
+    s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[0]);
+    s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[0]);
+
+    return(0);
 
-  return(0);
-  
 }
 
-/*! \brief Set RX frequencies 
+/*! \brief Set RX frequencies
  * \param device the hardware to use
  * \param openair0_cfg RF frontend parameters set by application
- * \returns 0 in success 
+ * \returns 0 in success
  */
 int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *openair0_cfg) {
 
-  usrp_state_t *s = (usrp_state_t*)device->priv;
-  static int first_call=1;
-  static double rf_freq,diff;
+    usrp_state_t *s = (usrp_state_t*)device->priv;
+    static int first_call=1;
+    static double rf_freq,diff;
 
-  uhd::tune_request_t rx_tune_req(openair0_cfg[0].rx_freq[0]);
+    uhd::tune_request_t rx_tune_req(openair0_cfg[0].rx_freq[0]);
 
-  rx_tune_req.rf_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
-  rx_tune_req.rf_freq = openair0_cfg[0].rx_freq[0];
-  rf_freq=openair0_cfg[0].rx_freq[0];
-  s->usrp->set_rx_freq(rx_tune_req);
+    rx_tune_req.rf_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+    rx_tune_req.rf_freq = openair0_cfg[0].rx_freq[0];
+    rf_freq=openair0_cfg[0].rx_freq[0];
+    s->usrp->set_rx_freq(rx_tune_req);
+
+    return(0);
 
-  return(0);
-  
 }
 
 /*! \brief Set Gains (TX/RX)
  * \param device the hardware to use
  * \param openair0_cfg RF frontend parameters set by application
- * \returns 0 in success 
+ * \returns 0 in success
  */
-int trx_usrp_set_gains(openair0_device* device, 
-		       openair0_config_t *openair0_cfg) {
-
-  usrp_state_t *s = (usrp_state_t*)device->priv;
-
-  s->usrp->set_tx_gain(openair0_cfg[0].tx_gain[0]);
-  ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(0);
-  // limit to maximum gain
-  if (openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] > gain_range.stop()) {
-    
-    printf("RX Gain 0 too high, reduce by %f dB\n",
-	   openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] - gain_range.stop());	   
-    exit(-1);
-  }
-  s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0]);
-  printf("Setting USRP RX gain to %f (rx_gain %f,gain_range.stop() %f)\n", openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0],openair0_cfg[0].rx_gain[0],gain_range.stop());
+int trx_usrp_set_gains(openair0_device* device,
+                       openair0_config_t *openair0_cfg) {
+
+    usrp_state_t *s = (usrp_state_t*)device->priv;
+
+    s->usrp->set_tx_gain(openair0_cfg[0].tx_gain[0]);
+    ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(0);
+    // limit to maximum gain
+    if (openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] > gain_range.stop()) {
+        LOG_E(PHY,"RX Gain 0 too high, reduce by %f dB\n",
+              openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] - gain_range.stop());
+        exit(-1);
+    }
+    s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0]);
+    LOG_I(PHY,"Setting USRP RX gain to %f (rx_gain %f,gain_range.stop() %f)\n",
+          openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0],
+          openair0_cfg[0].rx_gain[0],gain_range.stop());
 
   return(0);
 }
@@ -426,376 +335,310 @@ int trx_usrp_stop(openair0_device* device) {
 
 /*! \brief USRPB210 RX calibration table */
 rx_gain_calib_table_t calib_table_b210[] = {
-  {3500000000.0,44.0},
-  {2660000000.0,49.0},
-  {2300000000.0,50.0},
-  {1880000000.0,53.0},
-  {816000000.0,58.0},
-  {-1,0}};
+    {3500000000.0,44.0},
+    {2660000000.0,49.0},
+    {2300000000.0,50.0},
+    {1880000000.0,53.0},
+    {816000000.0,58.0},
+    {-1,0}
+};
 
 /*! \brief USRPB210 RX calibration table */
 rx_gain_calib_table_t calib_table_b210_38[] = {
-  {3500000000.0,44.0},
-  {2660000000.0,49.8},
-  {2300000000.0,51.0},
-  {1880000000.0,53.0},
-  {816000000.0,57.0},
-  {-1,0}};
+    {3500000000.0,44.0},
+    {2660000000.0,49.8},
+    {2300000000.0,51.0},
+    {1880000000.0,53.0},
+    {816000000.0,57.0},
+    {-1,0}
+};
 
 /*! \brief USRPx310 RX calibration table */
 rx_gain_calib_table_t calib_table_x310[] = {
-  {3500000000.0,77.0},
-  {2660000000.0,81.0},
-  {2300000000.0,81.0},
-  {1880000000.0,82.0},
-  {816000000.0,85.0},
-  {-1,0}};
-
-/*! \brief Set RX gain offset 
+    {3500000000.0,77.0},
+    {2660000000.0,81.0},
+    {2300000000.0,81.0},
+    {1880000000.0,82.0},
+    {816000000.0,85.0},
+    {-1,0}
+};
+
+/*! \brief Set RX gain offset
  * \param openair0_cfg RF frontend parameters set by application
  * \param chain_index RF chain to apply settings to
- * \returns 0 in success 
+ * \returns 0 in success
  */
 void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index,int bw_gain_adjust) {
 
-  int i=0;
-  // loop through calibration table to find best adjustment factor for RX frequency
-  double min_diff = 6e9,diff,gain_adj=0.0;
-  if (bw_gain_adjust==1) {
-    switch ((int)openair0_cfg[0].sample_rate) {
-    case 30720000:      
-      break;
-    case 23040000:
-      gain_adj=1.25;
-      break;
-    case 15360000:
-      gain_adj=3.0;
-      break;
-    case 7680000:
-      gain_adj=6.0;
-      break;
-    case 3840000:
-      gain_adj=9.0;
-      break;
-    case 1920000:
-      gain_adj=12.0;
-      break;
-    default:
-      printf("unknown sampling rate %d\n",(int)openair0_cfg[0].sample_rate);
-      exit(-1);
-      break;
+    int i=0;
+    // loop through calibration table to find best adjustment factor for RX frequency
+    double min_diff = 6e9,diff,gain_adj=0.0;
+    if (bw_gain_adjust==1) {
+        switch ((int)openair0_cfg[0].sample_rate) {
+        case 30720000:
+            break;
+        case 23040000:
+            gain_adj=1.25;
+            break;
+        case 15360000:
+            gain_adj=3.0;
+            break;
+        case 7680000:
+            gain_adj=6.0;
+            break;
+        case 3840000:
+            gain_adj=9.0;
+            break;
+        case 1920000:
+            gain_adj=12.0;
+            break;
+        default:
+            LOG_E(PHY,"unknown sampling rate %d\n",(int)openair0_cfg[0].sample_rate);
+            exit(-1);
+            break;
+        }
     }
-  }
-  while (openair0_cfg->rx_gain_calib_table[i].freq>0) {
-    diff = fabs(openair0_cfg->rx_freq[chain_index] - openair0_cfg->rx_gain_calib_table[i].freq);
-    printf("cal %d: freq %f, offset %f, diff %f\n",
-	   i,
-	   openair0_cfg->rx_gain_calib_table[i].freq,
+    while (openair0_cfg->rx_gain_calib_table[i].freq>0) {
+        diff = fabs(openair0_cfg->rx_freq[chain_index] - openair0_cfg->rx_gain_calib_table[i].freq);
+        LOG_I(PHY,"cal %d: freq %f, offset %f, diff %f\n",
+              i,
+              openair0_cfg->rx_gain_calib_table[i].freq,
 	   openair0_cfg->rx_gain_calib_table[i].offset,diff);
     if (min_diff > diff) {
       min_diff = diff;
       openair0_cfg->rx_gain_offset[chain_index] = openair0_cfg->rx_gain_calib_table[i].offset+gain_adj;
     }
     i++;
-  }
-  
+    }
 }
 
-/*! \brief print the USRP statistics  
+/*! \brief print the USRP statistics
 * \param device the hardware to use
 * \returns  0 on success
 */
 int trx_usrp_get_stats(openair0_device* device) {
-
-  return(0);
-
+    return(0);
 }
 
-/*! \brief Reset the USRP statistics  
-* \param device the hardware to use
-* \returns  0 on success
-*/
+/*! \brief Reset the USRP statistics
+ * \param device the hardware to use
+ * \returns  0 on success
+ */
 int trx_usrp_reset_stats(openair0_device* device) {
-
-  return(0);
-
+    return(0);
 }
 
-
-
 extern "C" {
-/*! \brief Initialize Openair USRP target. It returns 0 if OK
-* \param device the hardware to use
-* \param openair0_cfg RF frontend parameters set by application
-*/
-  int device_init(openair0_device* device, openair0_config_t *openair0_cfg) {
-    
-    uhd::set_thread_priority_safe(1.0);
-    usrp_state_t *s = (usrp_state_t*)malloc(sizeof(usrp_state_t));
-    memset(s, 0, sizeof(usrp_state_t));
-    
-    // Initialize USRP device
-
-  device->openair0_cfg = openair0_cfg;
-
-  std::string args = "type=b200";
-
-
-  uhd::device_addrs_t device_adds = uhd::device::find(args);
-  size_t i;
-  
-  int vers=0,subvers=0,subsubvers=0;
-  int bw_gain_adjust=0;
+    /*! \brief Initialize Openair USRP target. It returns 0 if OK
+    * \param device the hardware to use
+         * \param openair0_cfg RF frontend parameters set by application
+         */
+    int device_init(openair0_device* device, openair0_config_t *openair0_cfg) {
+        //uhd::set_thread_priority_safe(1.0);
+        usrp_state_t *s = (usrp_state_t*)calloc(sizeof(usrp_state_t),1);
+        // Initialize USRP device
+        device->openair0_cfg = openair0_cfg;
+
+        std::string args = "type=b200";
+        uhd::device_addrs_t device_adds = uhd::device::find(args);
+
+        int vers=0,subvers=0,subsubvers=0;
+        int bw_gain_adjust=0;
+
+        sscanf(uhd::get_version_string().c_str(),"%d.%d.%d",&vers,&subvers,&subsubvers);
+        LOG_I(PHY,"Checking for USRPs : UHD %s (%d.%d.%d)\n",
+              uhd::get_version_string().c_str(),vers,subvers,subsubvers);
+
+        if(device_adds.size() == 0)  {
+            double usrp_master_clock = 184.32e6;
+            std::string args = "type=x300";
 
-  sscanf(uhd::get_version_string().c_str(),"%d.%d.%d",&vers,&subvers,&subsubvers);
-
-  printf("Checking for USRPs : UHD %s (%d.%d.%d)\n",uhd::get_version_string().c_str(),vers,subvers,subsubvers);
-  
-  if(device_adds.size() == 0)
-  {
-    double usrp_master_clock = 184.32e6;
-
-    std::string args = "type=x300";
-    
     // workaround for an api problem, master clock has to be set with the constructor not via set_master_clock_rate
     args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
-    
-//    args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=4096, recv_frame_size=4096";
-    
-    uhd::device_addrs_t device_adds = uhd::device::find(args);
-
-    if(device_adds.size() == 0)
-    {
-      std::cerr<<"No USRP Device Found. " << std::endl;
-      free(s);
-      return -1;
-
-    }
-
-
-    printf("Found USRP X300\n");
-    s->usrp = uhd::usrp::multi_usrp::make(args);
-    //  s->usrp->set_rx_subdev_spec(rx_subdev);
-    //  s->usrp->set_tx_subdev_spec(tx_subdev);
-
-    // lock mboard clocks
-    s->usrp->set_clock_source("internal");
-    
-    //Setting device type to USRP X300/X310 
-    device->type=USRP_X300_DEV;
-
-    // this is not working yet, master clock has to be set via constructor
-    // set master clock rate and sample rate for tx & rx for streaming
-    //s->usrp->set_master_clock_rate(usrp_master_clock);
-
-    openair0_cfg[0].rx_gain_calib_table = calib_table_x310;
-    
-    switch ((int)openair0_cfg[0].sample_rate) {
-    case 30720000:
-            // from usrp_time_offset
-      //openair0_cfg[0].samples_per_packet    = 2048;
-      openair0_cfg[0].tx_sample_advance     = 15;
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    case 15360000:
-      //openair0_cfg[0].samples_per_packet    = 2048;
-      openair0_cfg[0].tx_sample_advance     = 45;
-      openair0_cfg[0].tx_bw                 = 10e6;
-      openair0_cfg[0].rx_bw                 = 10e6;
-      break;
-    case 7680000:
-      //openair0_cfg[0].samples_per_packet    = 2048;
-      openair0_cfg[0].tx_sample_advance     = 50;
-      openair0_cfg[0].tx_bw                 = 5e6;
-      openair0_cfg[0].rx_bw                 = 5e6;
-      break;
-    case 1920000:
-      //openair0_cfg[0].samples_per_packet    = 2048;
-      openair0_cfg[0].tx_sample_advance     = 50;
-      openair0_cfg[0].tx_bw                 = 1.25e6;
-      openair0_cfg[0].rx_bw                 = 1.25e6;
-      break;
-    default:
-      printf("Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
-      exit(-1);
-      break;
-    }
-
-  } else {
-    printf("Found USRP B200");
-    args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=15360, recv_frame_size=15360" ; 
-    s->usrp = uhd::usrp::multi_usrp::make(args);
-
-    //  s->usrp->set_rx_subdev_spec(rx_subdev);
-    //  s->usrp->set_tx_subdev_spec(tx_subdev);
-    
-    // do not explicitly set the clock to "internal", because this will disable the gpsdo
-    //    // lock mboard clocks
-    //    s->usrp->set_clock_source("internal");
-    // set master clock rate and sample rate for tx & rx for streaming
-
-    device->type = USRP_B200_DEV;
-
-
-    if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) {
-      openair0_cfg[0].rx_gain_calib_table = calib_table_b210;
-      bw_gain_adjust=0;
-    }
-    else {
-      openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38;
-      bw_gain_adjust=1;
-    }
-
-    switch ((int)openair0_cfg[0].sample_rate) {
-    case 30720000:
-      s->usrp->set_master_clock_rate(30.72e6);
-      //openair0_cfg[0].samples_per_packet    = 1024;
-      openair0_cfg[0].tx_sample_advance     = 115;
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    case 23040000:
-      s->usrp->set_master_clock_rate(23.04e6); //to be checked
-      //openair0_cfg[0].samples_per_packet    = 1024;
-      openair0_cfg[0].tx_sample_advance     = 113;
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    case 15360000:
-      s->usrp->set_master_clock_rate(30.72e06);
-      //openair0_cfg[0].samples_per_packet    = 1024;
-      openair0_cfg[0].tx_sample_advance     = 103; 
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    case 7680000:
-      s->usrp->set_master_clock_rate(30.72e6);
-      //openair0_cfg[0].samples_per_packet    = 1024;
-      openair0_cfg[0].tx_sample_advance     = 80;
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    case 1920000:
-      s->usrp->set_master_clock_rate(30.72e6);
-      //openair0_cfg[0].samples_per_packet    = 1024;
-      openair0_cfg[0].tx_sample_advance     = 40;
-      openair0_cfg[0].tx_bw                 = 20e6;
-      openair0_cfg[0].rx_bw                 = 20e6;
-      break;
-    default:
-      printf("Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
-      exit(-1);
-      break;
-    }
-  }
-
-  /* device specific */
-  //openair0_cfg[0].txlaunch_wait = 1;//manage when TX processing is triggered
-  //openair0_cfg[0].txlaunch_wait_slotcount = 1; //manage when TX processing is triggered
-  openair0_cfg[0].iq_txshift = 4;//shift
-  openair0_cfg[0].iq_rxrescale = 15;//rescale iqs
-  
-  for(i=0;i<s->usrp->get_rx_num_channels();i++) {
-    if (i<openair0_cfg[0].rx_num_channels) {
-      s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i);
-      //s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
-      //printf("Setting rx freq/gain on channel %lu/%lu : BW %f (readback %f)\n",i,s->usrp->get_rx_num_channels(),openair0_cfg[0].rx_bw/1e6,s->usrp->get_rx_bandwidth(i)/1e6);
-      s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i);
-      set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
-
-      ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i);
-      // limit to maximum gain
-      if (openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] > gain_range.stop()) {
-	
-        printf("RX Gain %lu too high, lower by %f dB\n",i,openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] - gain_range.stop());
-	exit(-1);
-      }
-      s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],i);
-      printf("RX Gain %lu %f (%f) => %f (max %f)\n",i,
-	     openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i],
-	     openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop());
-    }
-  }
-  for(i=0;i<s->usrp->get_tx_num_channels();i++) {
-    if (i<openair0_cfg[0].tx_num_channels) {
-      s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
-      //s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i);
-      //printf("Setting tx freq/gain on channel %lu/%lu: BW %f (readback %f)\n",i,s->usrp->get_tx_num_channels(),openair0_cfg[0].tx_bw/1e6,s->usrp->get_tx_bandwidth(i)/1e6);
-      s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
-      s->usrp->set_tx_gain(openair0_cfg[0].tx_gain[i],i);
-    }
-  }
-
-
-  // display USRP settings
-  std::cout << boost::format("Actual master clock: %fMHz...") % (s->usrp->get_master_clock_rate()/1e6) << std::endl;
-  
-  sleep(1);
-
-  // create tx & rx streamer
-  uhd::stream_args_t stream_args_rx("sc16", "sc16");
-  //stream_args_rx.args["spp"] = str(boost::format("%d") % 2048);//(openair0_cfg[0].rx_num_channels*openair0_cfg[0].samples_per_packet));
-  for (i = 0; i<openair0_cfg[0].rx_num_channels; i++)
-    stream_args_rx.channels.push_back(i);
-  s->rx_stream = s->usrp->get_rx_stream(stream_args_rx);
-  std::cout << boost::format("rx_max_num_samps %u") % (s->rx_stream->get_max_num_samps()) << std::endl;
-  //openair0_cfg[0].samples_per_packet = s->rx_stream->get_max_num_samps();
-
-  uhd::stream_args_t stream_args_tx("sc16", "sc16");
-  //stream_args_tx.args["spp"] = str(boost::format("%d") % 2048);//(openair0_cfg[0].tx_num_channels*openair0_cfg[0].samples_per_packet));
-  for (i = 0; i<openair0_cfg[0].tx_num_channels; i++)
-      stream_args_tx.channels.push_back(i);
-  s->tx_stream = s->usrp->get_tx_stream(stream_args_tx);
-  std::cout << boost::format("tx_max_num_samps %u") % (s->tx_stream->get_max_num_samps()) << std::endl;
-
-
- /* Setting TX/RX BW after streamers are created due to USRP calibration issue */
-  for(i=0;i<s->usrp->get_tx_num_channels();i++) {
-    if (i<openair0_cfg[0].tx_num_channels) {
-      s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i);
-      printf("Setting tx freq/gain on channel %lu/%lu: BW %f (readback %f)\n",i,s->usrp->get_tx_num_channels(),openair0_cfg[0].tx_bw/1e6,s->usrp->get_tx_bandwidth(i)/1e6);
-    }
-  }
-  for(i=0;i<s->usrp->get_rx_num_channels();i++) {
-    if (i<openair0_cfg[0].rx_num_channels) {
-      s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
-      printf("Setting rx freq/gain on channel %lu/%lu : BW %f (readback %f)\n",i,s->usrp->get_rx_num_channels(),openair0_cfg[0].rx_bw/1e6,s->usrp->get_rx_bandwidth(i)/1e6);
-    }
-  }
-
-  s->usrp->set_time_now(uhd::time_spec_t(0.0));
- 
-
-  for (i=0;i<openair0_cfg[0].rx_num_channels;i++) {
-    if (i<openair0_cfg[0].rx_num_channels) {
-      printf("RX Channel %lu\n",i);
-      std::cout << boost::format("Actual RX sample rate: %fMSps...") % (s->usrp->get_rx_rate(i)/1e6) << std::endl;
-      std::cout << boost::format("Actual RX frequency: %fGHz...") % (s->usrp->get_rx_freq(i)/1e9) << std::endl;
-      std::cout << boost::format("Actual RX gain: %f...") % (s->usrp->get_rx_gain(i)) << std::endl;
-      std::cout << boost::format("Actual RX bandwidth: %fM...") % (s->usrp->get_rx_bandwidth(i)/1e6) << std::endl;
-      std::cout << boost::format("Actual RX antenna: %s...") % (s->usrp->get_rx_antenna(i)) << std::endl;
-    }
-  }
-
-  for (i=0;i<openair0_cfg[0].tx_num_channels;i++) {
-
-    if (i<openair0_cfg[0].tx_num_channels) { 
-      printf("TX Channel %lu\n",i);
-      std::cout << std::endl<<boost::format("Actual TX sample rate: %fMSps...") % (s->usrp->get_tx_rate(i)/1e6) << std::endl;
-      std::cout << boost::format("Actual TX frequency: %fGHz...") % (s->usrp->get_tx_freq(i)/1e9) << std::endl;
-      std::cout << boost::format("Actual TX gain: %f...") % (s->usrp->get_tx_gain(i)) << std::endl;
-      std::cout << boost::format("Actual TX bandwidth: %fM...") % (s->usrp->get_tx_bandwidth(i)/1e6) << std::endl;
-      std::cout << boost::format("Actual TX antenna: %s...") % (s->usrp->get_tx_antenna(i)) << std::endl;
-    }
-  }
-
-  std::cout << boost::format("Device timestamp: %f...") % (s->usrp->get_time_now().get_real_secs()) << std::endl;
 
-  device->priv = s;
-  device->trx_start_func = trx_usrp_start;
-  device->trx_write_func = trx_usrp_write;
-  device->trx_read_func  = trx_usrp_read;
+            //    args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=4096, recv_frame_size=4096";
+            uhd::device_addrs_t device_adds = uhd::device::find(args);
+
+            if(device_adds.size() == 0) {
+                std::cerr<<"No USRP Device Found. " << std::endl;
+                free(s);
+                return -1;
+            }
+            LOG_I(PHY,"Found USRP X300\n");
+            s->usrp = uhd::usrp::multi_usrp::make(args);
+            // lock mboard clocks
+            s->usrp->set_clock_source("internal");
+
+            //Setting device type to USRP X300/X310
+            device->type=USRP_X300_DEV;
+
+            // this is not working yet, master clock has to be set via constructor
+            // set master clock rate and sample rate for tx & rx for streaming
+            //s->usrp->set_master_clock_rate(usrp_master_clock);
+
+            openair0_cfg[0].rx_gain_calib_table = calib_table_x310;
+
+            switch ((int)openair0_cfg[0].sample_rate) {
+            case 30720000:
+                // from usrp_time_offset
+                openair0_cfg[0].tx_sample_advance     = 15;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            case 15360000:
+                openair0_cfg[0].tx_sample_advance     = 45;
+                openair0_cfg[0].tx_bw                 = 10e6;
+                openair0_cfg[0].rx_bw                 = 10e6;
+                break;
+            case 7680000:
+                openair0_cfg[0].tx_sample_advance     = 50;
+                openair0_cfg[0].tx_bw                 = 5e6;
+                openair0_cfg[0].rx_bw                 = 5e6;
+                break;
+            case 1920000:
+                openair0_cfg[0].tx_sample_advance     = 50;
+                openair0_cfg[0].tx_bw                 = 1.25e6;
+                openair0_cfg[0].rx_bw                 = 1.25e6;
+                break;
+            default:
+                LOG_E(PHY,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
+                exit(-1);
+                break;
+            }
+
+        } else {
+            LOG_I(PHY,"Found USRP B200\n");
+            args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=15360, recv_frame_size=15360" ;
+            s->usrp = uhd::usrp::multi_usrp::make(args);
+            device->type = USRP_B200_DEV;
+            if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) {
+                openair0_cfg[0].rx_gain_calib_table = calib_table_b210;
+                bw_gain_adjust=0;
+            } else {
+                openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38;
+                bw_gain_adjust=1;
+            }
+
+            switch ((int)openair0_cfg[0].sample_rate) {
+            case 30720000:
+                s->usrp->set_master_clock_rate(30.72e6);
+                openair0_cfg[0].tx_sample_advance     = 115;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            case 23040000:
+                s->usrp->set_master_clock_rate(23.04e6); //to be checked
+                openair0_cfg[0].tx_sample_advance     = 113;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            case 15360000:
+                s->usrp->set_master_clock_rate(30.72e06);
+                openair0_cfg[0].tx_sample_advance     = 103;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            case 7680000:
+                s->usrp->set_master_clock_rate(30.72e6);
+                openair0_cfg[0].tx_sample_advance     = 80;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            case 1920000:
+                s->usrp->set_master_clock_rate(30.72e6);
+                openair0_cfg[0].tx_sample_advance     = 40;
+                openair0_cfg[0].tx_bw                 = 20e6;
+                openair0_cfg[0].rx_bw                 = 20e6;
+                break;
+            default:
+                LOG_E(PHY,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
+                exit(-1);
+                break;
+            }
+        }
+        openair0_cfg[0].iq_txshift = 4;//shift
+        openair0_cfg[0].iq_rxrescale = 15;//rescale iqs
+
+        for(int i=0; i<s->usrp->get_rx_num_channels(); i++) {
+            if (i<openair0_cfg[0].rx_num_channels) {
+                s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i);
+                s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i);
+                set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
+
+                ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i);
+                // limit to maximum gain
+                AssertFatal( openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] <= gain_range.stop(),
+                             "RX Gain too high, lower by %f dB\n",
+                             openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] - gain_range.stop());
+                s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],i);
+                LOG_I(PHY,"RX Gain %d %f (%f) => %f (max %f)\n",i,
+                      openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i],
+                      openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop());
+            }
+        }
+        for(int i=0; i<s->usrp->get_tx_num_channels(); i++) {
+            if (i<openair0_cfg[0].tx_num_channels) {
+                s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
+                s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
+                s->usrp->set_tx_gain(openair0_cfg[0].tx_gain[i],i);
+            }
+        }
+
+        //s->usrp->set_clock_source("external");
+        //s->usrp->set_time_source("external");
+
+        // display USRP settings
+        LOG_I(PHY,"Actual master clock: %fMHz...\n",s->usrp->get_master_clock_rate()/1e6);
+
+        // create tx & rx streamer
+        uhd::stream_args_t stream_args_rx("sc16", "sc16");
+        int samples=openair0_cfg[0].sample_rate;
+        //while ( samples > s->rx_stream->get_max_num_samps())
+        samples/=24000;
+        stream_args_rx.args["spp"] = str(boost::format("%d") % samples );
+        for (int i = 0; i<openair0_cfg[0].rx_num_channels; i++)
+            stream_args_rx.channels.push_back(i);
+        s->rx_stream = s->usrp->get_rx_stream(stream_args_rx);
+        LOG_I(PHY,"rx_max_num_samps %u\n",s->rx_stream->get_max_num_samps());
+
+        uhd::stream_args_t stream_args_tx("sc16", "sc16");
+        for (int i = 0; i<openair0_cfg[0].tx_num_channels; i++)
+            stream_args_tx.channels.push_back(i);
+        s->tx_stream = s->usrp->get_tx_stream(stream_args_tx);
+
+        /* Setting TX/RX BW after streamers are created due to USRP calibration issue */
+        for(int i=0; i<s->usrp->get_tx_num_channels() && i<openair0_cfg[0].tx_num_channels; i++)
+            s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i);
+
+        for(int i=0; i<s->usrp->get_rx_num_channels() && i<openair0_cfg[0].rx_num_channels; i++)
+            s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
+
+        s->usrp->set_time_now(uhd::time_spec_t(0.0));
+
+        for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) {
+            LOG_I(PHY,"RX Channel %d\n",i);
+            LOG_I(PHY,"  Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i)/1e6);
+            LOG_I(PHY,"  Actual RX frequency: %fGHz...\n", s->usrp->get_rx_freq(i)/1e9);
+            LOG_I(PHY,"  Actual RX gain: %f...\n", s->usrp->get_rx_gain(i));
+            LOG_I(PHY,"  Actual RX bandwidth: %fM...\n", s->usrp->get_rx_bandwidth(i)/1e6);
+            LOG_I(PHY,"  Actual RX antenna: %s...\n", s->usrp->get_rx_antenna(i).c_str());
+        }
+
+        for (int i=0; i<openair0_cfg[0].tx_num_channels; i++) {
+            LOG_I(PHY,"TX Channel %d\n",i);
+            LOG_I(PHY,"  Actual TX sample rate: %fMSps...\n", s->usrp->get_tx_rate(i)/1e6);
+            LOG_I(PHY,"  Actual TX frequency: %fGHz...\n", s->usrp->get_tx_freq(i)/1e9);
+            LOG_I(PHY,"  Actual TX gain: %f...\n", s->usrp->get_tx_gain(i));
+            LOG_I(PHY,"  Actual TX bandwidth: %fM...\n", s->usrp->get_tx_bandwidth(i)/1e6);
+            LOG_I(PHY,"  Actual TX antenna: %s...\n", s->usrp->get_tx_antenna(i).c_str());
+        }
+
+        LOG_I(PHY,"Device timestamp: %f...\n", s->usrp->get_time_now().get_real_secs());
+
+        device->priv = s;
+        device->trx_start_func = trx_usrp_start;
+        device->trx_write_func = trx_usrp_write;
+        device->trx_read_func  = trx_usrp_read;
   device->trx_get_stats_func = trx_usrp_get_stats;
   device->trx_reset_stats_func = trx_usrp_reset_stats;
   device->trx_end_func   = trx_usrp_end;
diff --git a/targets/RT/USER/lte-ue.c b/targets/RT/USER/lte-ue.c
index 5ab6b7cddf..6e588f7f3c 100644
--- a/targets/RT/USER/lte-ue.c
+++ b/targets/RT/USER/lte-ue.c
@@ -75,15 +75,113 @@
 #include "UTIL/LOG/vcd_signal_dumper.h"
 #include "UTIL/OPT/opt.h"
 
+
+#define DEBUG_REALTIME 1
+#if DEBUG_REALTIME
+
+typedef struct latency_stat {
+    uint64_t		counter;
+    uint64_t		stat1100;
+    uint64_t		stat1200;
+    uint64_t		stat1500;
+    uint64_t		stat2000;
+    uint64_t		stat3000;
+} latency_stat_t;
+
+static inline void saif_meas(int frame_rx) {
+    static latency_stat_t __thread latency_stat;
+    static struct timespec __thread last= {0};
+    struct timespec now;
+    clock_gettime(CLOCK_MONOTONIC_RAW, &now);
+    if ( last.tv_sec )  {
+        uint64_t diffTime =  ((uint64_t)now.tv_sec *1000 *1000 *1000 + now.tv_nsec) -
+                             ((uint64_t)last.tv_sec *1000 *1000 *1000 + last.tv_nsec);
+        diffTime/=1000;
+        latency_stat.counter++;
+        if ( diffTime >= 1100 ) {
+            if (diffTime  < 1200 )
+                latency_stat.stat1100++;
+            else if ( diffTime < 1500 )
+                latency_stat.stat1200++;
+            else if ( diffTime < 2000 )
+                latency_stat.stat1500++;
+            else if ( diffTime < 3000 )
+                latency_stat.stat2000++;
+            else
+                latency_stat.stat3000++;
+        }
+        if ( diffTime>=1100 || latency_stat.counter%20000==0 ) {
+            time_t current=time(NULL);
+            LOG_W(HW,
+                  "%.2f delay=%llu Period stats %2.6f%% below 100碌s\ncumul of events: 1100=%ld 1200=%ld 1500=%ld 2000=%ld >3000=%ld - (frame_rx=%d) - %s",
+                  now.tv_sec+(double)now.tv_nsec/1e9,
+                  diffTime,
+                  (latency_stat.counter-latency_stat.stat1100-latency_stat.stat1200-
+                   latency_stat.stat1500-latency_stat.stat2000-latency_stat.stat3000)/
+                  (float)latency_stat.counter *100,
+                  latency_stat.stat1100, latency_stat.stat1200,
+                  latency_stat.stat1500, latency_stat.stat2000,
+                  latency_stat.stat3000,
+                  frame_rx, ctime(&current));
+            fflush(stdout);
+        }
+
+    }
+    last=now;
+}
+
+typedef struct m {
+    unsigned long long iterations;
+    unsigned long long sum;
+    unsigned long long maxArray[11];
+} Meas;
+
+
+void printMeas(char * txt, Meas *M, int period) {
+    if (M->iterations%period == 0 ) {
+        char txt2[512];
+        sprintf(txt2,"%s avg=%llu, iterations=%llu, max=%llu/%llu/%llu/%llu/%llu/%llu/%llu/%llu/%llu/%llu\n",
+                txt, M->sum/M->iterations,M->iterations,
+                M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4],
+                M->maxArray[5], M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
+        LOG_W(PHY,txt2);
+    }
+}
+
+int cmpint(const void* a, const void* b) {
+    unsigned long long* aa=(unsigned long long*)a;
+    unsigned long long* bb=(unsigned long long*)b;
+    return (int)(*aa-*bb);
+}
+
+void updateTimes(unsigned long long start, Meas *M, int period, char * txt) {
+    unsigned long long end=rdtsc();
+    long long diff=(end-start)/(cpuf*1000);
+    M->maxArray[0]=diff;
+    M->sum+=diff;
+    M->iterations++;
+    qsort(M->maxArray, 11, sizeof(unsigned long long), cmpint);
+    printMeas(txt,M,period);
+}
+
+#else
+#define check(a) do {} while (0)
+#define saif_meas(a) do {} while (0)
+#define update_max_times(a,b) do {} while (0)
+#define print_meas(a,b) do {} while (0)
+#endif
+/* End of Changed by SYRTEM */
+
 #define FRAME_PERIOD    100000000ULL
 #define DAQ_PERIOD      66667ULL
 
 typedef enum {
-  pss=0,
-  pbch=1,
-  si=2
+    pss=0,
+    pbch=1,
+    si=2
 } sync_mode_t;
 
+
 void init_UE_threads(int nb_inst);
 void *UE_thread(void *arg);
 void init_UE(int nb_inst);
@@ -92,7 +190,6 @@ extern pthread_cond_t sync_cond;
 extern pthread_mutex_t sync_mutex;
 extern int sync_var;
 
-
 extern openair0_config_t openair0_cfg[MAX_CARDS];
 extern uint32_t          downlink_frequency[MAX_NUM_CCs][4];
 extern int32_t           uplink_frequency_offset[MAX_NUM_CCs][4];
@@ -114,96 +211,122 @@ extern void exit_fun(const char* s);
 #define MHz (1000 * KHz)
 
 typedef struct eutra_band_s {
-  int16_t band;
-  uint32_t ul_min;
-  uint32_t ul_max;
-  uint32_t dl_min;
-  uint32_t dl_max;
-  lte_frame_type_t frame_type;
+    int16_t band;
+    uint32_t ul_min;
+    uint32_t ul_max;
+    uint32_t dl_min;
+    uint32_t dl_max;
+    lte_frame_type_t frame_type;
 } eutra_band_t;
 
 typedef struct band_info_s {
-  int nbands;
-  eutra_band_t band_info[100];
+    int nbands;
+    eutra_band_t band_info[100];
 } band_info_t;
 
 band_info_t bands_to_scan;
 
 static const eutra_band_t eutra_bands[] = {
-  { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
-  { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
-  { 3, 1710    * MHz, 1785    * MHz, 1805    * MHz, 1880    * MHz, FDD},
-  { 4, 1710    * MHz, 1755    * MHz, 2110    * MHz, 2155    * MHz, FDD},
-  { 5,  824    * MHz,  849    * MHz,  869    * MHz,  894    * MHz, FDD},
-  { 6,  830    * MHz,  840    * MHz,  875    * MHz,  885    * MHz, FDD},
-  { 7, 2500    * MHz, 2570    * MHz, 2620    * MHz, 2690    * MHz, FDD},
-  { 8,  880    * MHz,  915    * MHz,  925    * MHz,  960    * MHz, FDD},
-  { 9, 1749900 * KHz, 1784900 * KHz, 1844900 * KHz, 1879900 * KHz, FDD},
-  {10, 1710    * MHz, 1770    * MHz, 2110    * MHz, 2170    * MHz, FDD},
-  {11, 1427900 * KHz, 1452900 * KHz, 1475900 * KHz, 1500900 * KHz, FDD},
-  {12,  698    * MHz,  716    * MHz,  728    * MHz,  746    * MHz, FDD},
-  {13,  777    * MHz,  787    * MHz,  746    * MHz,  756    * MHz, FDD},
-  {14,  788    * MHz,  798    * MHz,  758    * MHz,  768    * MHz, FDD},
-  {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},
-  {20,  832    * MHz,  862    * MHz,  791    * MHz,  821    * MHz, FDD},
-  {22, 3510    * MHz, 3590    * MHz, 3410    * MHz, 3490    * MHz, FDD},
-  {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
-  {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
-  {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
-  {36, 1930    * MHz, 1990    * MHz, 1930    * MHz, 1990    * MHz, TDD},
-  {37, 1910    * MHz, 1930    * MHz, 1910    * MHz, 1930    * MHz, TDD},
-  {38, 2570    * MHz, 2620    * MHz, 2570    * MHz, 2630    * MHz, TDD},
-  {39, 1880    * MHz, 1920    * MHz, 1880    * MHz, 1920    * MHz, TDD},
-  {40, 2300    * MHz, 2400    * MHz, 2300    * MHz, 2400    * MHz, TDD},
-  {41, 2496    * MHz, 2690    * MHz, 2496    * MHz, 2690    * MHz, TDD},
-  {42, 3400    * MHz, 3600    * MHz, 3400    * MHz, 3600    * MHz, TDD},
-  {43, 3600    * MHz, 3800    * MHz, 3600    * MHz, 3800    * MHz, TDD},
-  {44, 703    * MHz, 803    * MHz, 703    * MHz, 803    * MHz, TDD},
+    { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
+    { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
+    { 3, 1710    * MHz, 1785    * MHz, 1805    * MHz, 1880    * MHz, FDD},
+    { 4, 1710    * MHz, 1755    * MHz, 2110    * MHz, 2155    * MHz, FDD},
+    { 5,  824    * MHz,  849    * MHz,  869    * MHz,  894    * MHz, FDD},
+    { 6,  830    * MHz,  840    * MHz,  875    * MHz,  885    * MHz, FDD},
+    { 7, 2500    * MHz, 2570    * MHz, 2620    * MHz, 2690    * MHz, FDD},
+    { 8,  880    * MHz,  915    * MHz,  925    * MHz,  960    * MHz, FDD},
+    { 9, 1749900 * KHz, 1784900 * KHz, 1844900 * KHz, 1879900 * KHz, FDD},
+    {10, 1710    * MHz, 1770    * MHz, 2110    * MHz, 2170    * MHz, FDD},
+    {11, 1427900 * KHz, 1452900 * KHz, 1475900 * KHz, 1500900 * KHz, FDD},
+    {12,  698    * MHz,  716    * MHz,  728    * MHz,  746    * MHz, FDD},
+    {13,  777    * MHz,  787    * MHz,  746    * MHz,  756    * MHz, FDD},
+    {14,  788    * MHz,  798    * MHz,  758    * MHz,  768    * MHz, FDD},
+    {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},
+    {20,  832    * MHz,  862    * MHz,  791    * MHz,  821    * MHz, FDD},
+    {22, 3510    * MHz, 3590    * MHz, 3410    * MHz, 3490    * MHz, FDD},
+    {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
+    {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
+    {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
+    {36, 1930    * MHz, 1990    * MHz, 1930    * MHz, 1990    * MHz, TDD},
+    {37, 1910    * MHz, 1930    * MHz, 1910    * MHz, 1930    * MHz, TDD},
+    {38, 2570    * MHz, 2620    * MHz, 2570    * MHz, 2630    * MHz, TDD},
+    {39, 1880    * MHz, 1920    * MHz, 1880    * MHz, 1920    * MHz, TDD},
+    {40, 2300    * MHz, 2400    * MHz, 2300    * MHz, 2400    * MHz, TDD},
+    {41, 2496    * MHz, 2690    * MHz, 2496    * MHz, 2690    * MHz, TDD},
+    {42, 3400    * MHz, 3600    * MHz, 3400    * MHz, 3600    * MHz, TDD},
+    {43, 3600    * MHz, 3800    * MHz, 3600    * MHz, 3800    * MHz, TDD},
+    {44, 703    * MHz, 803    * MHz, 703    * MHz, 803    * MHz, TDD},
 };
 
 pthread_t                       main_ue_thread;
 pthread_attr_t                  attr_UE_thread;
 struct sched_param              sched_param_UE_thread;
 
+void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char * name) {
+
+#ifdef DEADLINE_SCHEDULER
+    if (sched_runtime!=0) {
+        struct sched_attr attr= {0};
+        attr.size = sizeof(attr);
+        // This creates a .5 ms  reservation
+        attr.sched_policy = SCHED_DEADLINE;
+        attr.sched_runtime  = sched_runtime;
+        attr.sched_deadline = sched_deadline;
+        attr.sched_period   = 0;
+        AssertFatal(sched_setattr(0, &attr, 0) == 0,
+                    "[SCHED] main eNB thread: sched_setattr failed %s \n",perror(errno));
+        LOG_I(HW,"[SCHED][eNB] eNB main deadline thread %lu started on CPU %d\n",
+              (unsigned long)gettid(), sched_getcpu());
+    }
+
+#else
+    if (cpuset!=NULL)
+        AssertFatal( 0 == pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), cpuset), "");
+    struct sched_param sp;
+    sp.sched_priority = sched_fifo;
+    AssertFatal(pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp)==0,
+                "Can't set thread priority, Are you root?\n");
+#endif
+
+    // Lock memory from swapping. This is a process wide call (not constraint to this thread).
+    mlockall(MCL_CURRENT | MCL_FUTURE);
+    pthread_setname_np( pthread_self(), name );
+
+    // LTS: this sync stuff should be wrong
+    printf("waiting for sync (%s)\n",name);
+    pthread_mutex_lock(&sync_mutex);
+    printf("Locked sync_mutex, waiting (%s)\n",name);
+    while (sync_var<0)
+        pthread_cond_wait(&sync_cond, &sync_mutex);
+    pthread_mutex_unlock(&sync_mutex);
+    printf("starting %s\n",name);
+}
+
 void init_UE(int nb_inst) {
 
-  int error_code;
-  int inst;
-  PHY_VARS_UE *UE;
-  int ret;
+    PHY_VARS_UE *UE;
 
-  for (inst=0;inst<nb_inst;inst++) {
-    printf("Intializing UE Threads for instance %d ...\n",inst);
-    init_UE_threads(inst);
-    sleep(1);
-    UE = PHY_vars_UE_g[inst][0];
+    for (int inst=0; inst<nb_inst; inst++) {
+        printf("Intializing UE Threads for instance %d ...\n",inst);
+        init_UE_threads(inst);
+        sleep(1);
+        UE = PHY_vars_UE_g[inst][0];
 
-    ret = openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]);
-    if (ret !=0){
-       exit_fun("Error loading device library");
-    }
-    UE->rfdevice.host_type = BBU_HOST;
-    //    UE->rfdevice.type      = NONE_DEV;
-    error_code = pthread_create(&UE->proc.pthread_ue, &UE->proc.attr_ue, UE_thread, NULL);
-    
-    if (error_code!= 0) {
-      LOG_D(HW,"[lte-softmodem.c] Could not allocate UE_thread, error %d\n",error_code);
-      return;
-    } else {
-      LOG_D(HW, "[lte-softmodem.c] Allocate UE_thread successful\n" );
-      pthread_setname_np( UE->proc.pthread_ue, "main UE" );
+        AssertFatal(0== openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]), "");
+
+        UE->rfdevice.host_type = BBU_HOST;
+        //    UE->rfdevice.type      = NONE_DEV;
+        AssertFatal(0 == pthread_create(&UE->proc.pthread_ue, &UE->proc.attr_ue, UE_thread, NULL), "");
+        pthread_setname_np( UE->proc.pthread_ue, "main UE" );
     }
-  }
 
-  printf("UE threads created\n");
+    printf("UE threads created\n");
 #ifdef USE_MME
-  
-  while (start_UE == 0) {
-    sleep(1);
-  }
-  
+    while (start_UE == 0) {
+        sleep(1);
+    }
 #endif
-  
+
 }
 
 /*!
@@ -212,648 +335,491 @@ void init_UE(int nb_inst) {
  * \param arg is a pointer to a \ref PHY_VARS_UE structure.
  * \returns a pointer to an int. The storage is not on the heap and must not be freed.
  */
-static void *UE_thread_synch(void *arg)
-{
-  static int UE_thread_synch_retval;
-  int i, hw_slot_offset;
-  PHY_VARS_UE *UE = (PHY_VARS_UE*) arg;
-  int current_band = 0;
-  int current_offset = 0;
-  sync_mode_t sync_mode = pbch;
-  int CC_id = UE->CC_id;
-  int ind;
-  int found;
-  int freq_offset=0;
-
-  UE->is_synchronized = 0;
-  printf("UE_thread_sync in with PHY_vars_UE %p\n",arg);
-  printf("waiting for sync (UE_thread_synch) \n");
+static void *UE_thread_synch(void *arg) {
+    static int __thread UE_thread_synch_retval;
+    int i, hw_slot_offset;
+    PHY_VARS_UE *UE = (PHY_VARS_UE*) arg;
+    int current_band = 0;
+    int current_offset = 0;
+    sync_mode_t sync_mode = pbch;
+    int CC_id = UE->CC_id;
+    int ind;
+    int found;
+    int freq_offset=0;
+
+    UE->is_synchronized = 0;
+    printf("UE_thread_sync in with PHY_vars_UE %p\n",arg);
+    printf("waiting for sync (UE_thread_synch) \n");
 
 #ifndef DEADLINE_SCHEDULER
-  int policy, s, j;
-  struct sched_param sparam;
-  char cpu_affinity[1024];
-  cpu_set_t cpuset;
-
-  /* Set affinity mask to include CPUs 1 to MAX_CPUS */
-  /* CPU 0 is reserved for UHD threads */
-  CPU_ZERO(&cpuset);
-
-  #ifdef CPU_AFFINITY
-  if (get_nprocs() >2)
-  {
-    for (j = 1; j < get_nprocs(); j++)
-      CPU_SET(j, &cpuset);
-
-    s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-    if (s != 0)
-    {
-      perror( "pthread_setaffinity_np");
-      exit_fun("Error setting processor affinity");
+    int policy, s, j;
+    struct sched_param sparam;
+    char cpu_affinity[1024];
+    cpu_set_t cpuset;
+
+    /* Set affinity mask to include CPUs 1 to MAX_CPUS */
+    /* CPU 0 is reserved for UHD threads */
+    CPU_ZERO(&cpuset);
+
+#ifdef CPU_AFFINITY
+    if (get_nprocs() >2) {
+        for (j = 1; j < get_nprocs(); j++)
+            CPU_SET(j, &cpuset);
+
+        s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+        if (s != 0) {
+            perror( "pthread_setaffinity_np");
+            exit_fun("Error setting processor affinity");
+        }
     }
-  }
-  #endif
-
-  /* Check the actual affinity mask assigned to the thread */
-
-  s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  if (s != 0)
-  {
-    perror( "pthread_getaffinity_np");
-    exit_fun("Error getting processor affinity ");
-  }
-  memset(cpu_affinity, 0 , sizeof(cpu_affinity));
-  for (j = 0; j < CPU_SETSIZE; j++)
-  if (CPU_ISSET(j, &cpuset))
-  {  
-     char temp[1024];
-     sprintf(temp, " CPU_%d ", j);    
-     strcat(cpu_affinity, temp);
-  }
-
-  memset(&sparam, 0 , sizeof (sparam));
-  sparam.sched_priority = sched_get_priority_max(SCHED_FIFO)-1;
-  policy = SCHED_FIFO ; 
-  
-  s = pthread_setschedparam(pthread_self(), policy, &sparam);
-  if (s != 0)
-     {
-     perror("pthread_setschedparam : ");
-     exit_fun("Error setting thread priority");
-     }
-  s = pthread_getschedparam(pthread_self(), &policy, &sparam);
-  if (s != 0)
-   {
-     perror("pthread_getschedparam : ");
-     exit_fun("Error getting thread priority");
-
-   }
-
-  LOG_I( HW, "[SCHED][UE] Started UE synch thread on CPU %d TID %ld , sched_policy = %s, priority = %d, CPU Affinity = %s \n", (int)sched_getcpu(), gettid(),
-                   (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
-                   (policy == SCHED_RR)    ? "SCHED_RR" :
-                   (policy == SCHED_OTHER) ? "SCHED_OTHER" :
-                   "???",
-                   (int) sparam.sched_priority, cpu_affinity);
-
 #endif
 
+    /* Check the actual affinity mask assigned to the thread */
 
+    s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+    if (s != 0) {
+        perror( "pthread_getaffinity_np");
+        exit_fun("Error getting processor affinity ");
+    }
+    memset(cpu_affinity, 0 , sizeof(cpu_affinity));
+    for (j = 0; j < CPU_SETSIZE; j++)
+        if (CPU_ISSET(j, &cpuset)) {
+            char temp[1024];
+            sprintf(temp, " CPU_%d ", j);
+            strcat(cpu_affinity, temp);
+        }
 
+    memset(&sparam, 0 , sizeof (sparam));
+    sparam.sched_priority = sched_get_priority_max(SCHED_FIFO)-1;
+    policy = SCHED_FIFO ;
 
-  printf("starting UE synch thread (IC %d)\n",UE->proc.instance_cnt_synch);
-  ind = 0;
-  found = 0;
-
-
-  if (UE->UE_scan == 0) {
-    do  {
-      current_band = eutra_bands[ind].band;
-      printf( "Scanning band %d, dl_min %"PRIu32", ul_min %"PRIu32"\n", current_band, eutra_bands[ind].dl_min,eutra_bands[ind].ul_min);
+    s = pthread_setschedparam(pthread_self(), policy, &sparam);
+    if (s != 0) {
+        perror("pthread_setschedparam : ");
+        exit_fun("Error setting thread priority");
+    }
+    s = pthread_getschedparam(pthread_self(), &policy, &sparam);
+    if (s != 0) {
+        perror("pthread_getschedparam : ");
+        exit_fun("Error getting thread priority");
 
-      if ((eutra_bands[ind].dl_min <= downlink_frequency[0][0]) && (eutra_bands[ind].dl_max >= downlink_frequency[0][0])) {
-	for (i=0; i<4; i++)
-	  uplink_frequency_offset[CC_id][i] = eutra_bands[ind].ul_min - eutra_bands[ind].dl_min;
+    }
 
-        found = 1;
-        break;
-      }
+    LOG_I( HW, "[SCHED][UE] Started UE synch thread on CPU %d TID %ld , sched_policy = %s, priority = %d, CPU Affinity = %s \n", (int)sched_getcpu(), gettid(),
+           (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
+           (policy == SCHED_RR)    ? "SCHED_RR" :
+           (policy == SCHED_OTHER) ? "SCHED_OTHER" :
+           "???",
+           (int) sparam.sched_priority, cpu_affinity);
 
-      ind++;
-    } while (ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]));
-  
-    if (found == 0) {
-      exit_fun("Can't find EUTRA band for frequency");
-      return &UE_thread_synch_retval;
-    }
+#endif
 
+    printf("starting UE synch thread (IC %d)\n",UE->proc.instance_cnt_synch);
+    ind = 0;
+    found = 0;
 
 
+    if (UE->UE_scan == 0) {
+        do  {
+            current_band = eutra_bands[ind].band;
+            printf( "Scanning band %d, dl_min %"PRIu32", ul_min %"PRIu32"\n", current_band, eutra_bands[ind].dl_min,eutra_bands[ind].ul_min);
 
+            if ((eutra_bands[ind].dl_min <= downlink_frequency[0][0]) && (eutra_bands[ind].dl_max >= downlink_frequency[0][0])) {
+                for (i=0; i<4; i++)
+                    uplink_frequency_offset[CC_id][i] = eutra_bands[ind].ul_min - eutra_bands[ind].dl_min;
 
+                found = 1;
+                break;
+            }
 
-    LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n", downlink_frequency[0][0], downlink_frequency[0][0]+uplink_frequency_offset[0][0],oai_exit, openair0_cfg[0].rx_num_channels);
+            ind++;
+        } while (ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]));
 
-    for (i=0;i<openair0_cfg[UE->rf_map.card].rx_num_channels;i++) {
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-      openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-      if (uplink_frequency_offset[CC_id][i] != 0) // 
-	openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
-      else //FDD
-	openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
-    }
+        if (found == 0) {
+            exit_fun("Can't find EUTRA band for frequency");
+            return &UE_thread_synch_retval;
+        }
 
-    sync_mode = pbch;
 
-  } else if  (UE->UE_scan == 1) {
-    current_band=0;
 
-    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-      downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
-      uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].ul_min-bands_to_scan.band_info[CC_id].dl_min;
-      
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-      openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
-    }
-  }
 
 
-  pthread_mutex_lock(&sync_mutex);
-  printf("Locked sync_mutex, waiting (UE_sync_thread)\n");
 
-  while (sync_var<0)
-    pthread_cond_wait(&sync_cond, &sync_mutex);
+        LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n", downlink_frequency[0][0], downlink_frequency[0][0]+uplink_frequency_offset[0][0],oai_exit, openair0_cfg[0].rx_num_channels);
 
-  pthread_mutex_unlock(&sync_mutex);
-  printf("Started device, unlocked sync_mutex (UE_sync_thread)\n");
+        for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+            openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+            if (uplink_frequency_offset[CC_id][i] != 0) //
+                openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
+            else //FDD
+                openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
+        }
 
-  if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) { 
-    LOG_E(HW,"Could not start the device\n");
-    oai_exit=1;
-  }
+        sync_mode = pbch;
 
-  while (oai_exit==0) {
+    } else if  (UE->UE_scan == 1) {
+        current_band=0;
 
-    if (pthread_mutex_lock(&UE->proc.mutex_synch) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE initial synch thread\n" );
-      exit_fun("noting to add");
-      return &UE_thread_synch_retval;
-    }
-    
+        for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+            downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
+            uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].ul_min-bands_to_scan.band_info[CC_id].dl_min;
 
-    while (UE->proc.instance_cnt_synch < 0) {
-      // the thread waits here most of the time
-      pthread_cond_wait( &UE->proc.cond_synch, &UE->proc.mutex_synch );
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+        }
     }
 
-    if (pthread_mutex_unlock(&UE->proc.mutex_synch) != 0) {
-      LOG_E( PHY, "[SCHED][eNB] error unlocking mutex for UE Initial Synch thread\n" );
-      exit_fun("nothing to add");
-      return &UE_thread_synch_retval;
-    }
 
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 1 );
+    pthread_mutex_lock(&sync_mutex);
+    printf("Locked sync_mutex, waiting (UE_sync_thread)\n");
 
-    switch (sync_mode) {
-    case pss:
-      LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
-      lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
-      current_offset += 20000000; // increase by 20 MHz
+    while (sync_var<0)
+        pthread_cond_wait(&sync_cond, &sync_mutex);
 
-      if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
-        current_band++;
-        current_offset=0;
-      }
+    pthread_mutex_unlock(&sync_mutex);
+    printf("Started device, unlocked sync_mutex (UE_sync_thread)\n");
 
-      if (current_band==bands_to_scan.nbands) {
-        current_band=0;
+    if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
+        LOG_E(HW,"Could not start the device\n");
         oai_exit=1;
-      }
-
-      for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-	downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
-	uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].ul_min-bands_to_scan.band_info[0].dl_min + current_offset;
-
-	openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-	openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-	openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
-	if (UE->UE_scan_carrier) {
-	  openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-	}
-	
-      }
-
-      break;
- 
-    case pbch:
-
-      LOG_I(PHY,"[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
-      if (initial_sync( UE, UE->mode ) == 0) {
-
-        hw_slot_offset = (UE->rx_offset<<1) / UE->frame_parms.samples_per_tti;
-        LOG_I( HW, "Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %d (DL %u, UL %u), UE_scan_carrier %d\n",
-          hw_slot_offset,
-          freq_offset,
-          UE->rx_total_gain_dB,
-          downlink_frequency[0][0]+freq_offset,
-          downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset,
-          UE->UE_scan_carrier );
-
-	if (UE->UE_scan_carrier == 1) {
-
-	  UE->UE_scan_carrier = 0;
-	  // rerun with new cell parameters and frequency-offset
-	  for (i=0;i<openair0_cfg[UE->rf_map.card].rx_num_channels;i++) {
-	    openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
-	    openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= UE->common_vars.freq_offset;
-	    openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =  openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
-	    downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
-	    freq_offset=0;	    
-	  }
-
-	  // reconfigure for potentially different bandwidth
-	  switch(UE->frame_parms.N_RB_DL) {
-	  case 6:
-	    openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
-	    openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
-	    openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
-	    //            openair0_cfg[0].rx_gain[0] -= 12;
-	    break;
-	  case 25:
-	    openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
-	    openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
-	    openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
-	    //            openair0_cfg[0].rx_gain[0] -= 6;
-	    break;
-	  case 50:
-	    openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
-	    openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
-	    openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
-	    //            openair0_cfg[0].rx_gain[0] -= 3;
-	    break;
-	  case 100:
-	    openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
-	    openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
-	    openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
-	    //            openair0_cfg[0].rx_gain[0] -= 0;
-	    break;
-	  }
-	
-	  UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
-	  //UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
-	  UE->rfdevice.trx_stop_func(&UE->rfdevice);	  
-	  sleep(1);
-	  init_frame_parms(&UE->frame_parms,1);
-	  if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) { 
-	    LOG_E(HW,"Could not start the device\n");
-	    oai_exit=1;
-	  }
-	}
-	else {
-	  UE->is_synchronized = 1;
-
-	  if( UE->mode == rx_dump_frame ){
-	    FILE *fd;
-	    if ((UE->proc.proc_rxtx[0].frame_rx&1) == 0) {  // this guarantees SIB1 is present 
-	      if ((fd = fopen("rxsig_frame0.dat","w")) != NULL) {
-		fwrite((void*)&UE->common_vars.rxdata[0][0],
-		       sizeof(int32_t),
-		       10*UE->frame_parms.samples_per_tti,
-		       fd);
-		LOG_I(PHY,"Dummping Frame ... bye bye \n");
-		fclose(fd);
-		exit(0);
-	      }
-	      else {
-		LOG_E(PHY,"Cannot open file for writing\n");
-		exit(0);
-	      }
-	    }
-	    else {
-	      UE->is_synchronized = 0;
-	    }
-	  }
-	}
-      } else {
-        // initial sync failed
-        // calculate new offset and try again
-	if (UE->UE_scan_carrier == 1) {
-	  if (freq_offset >= 0) {
-	    freq_offset += 100;
-	    freq_offset *= -1;
-	  } else {
-	    freq_offset *= -1;
-	  }
-	
-	  if (abs(freq_offset) > 7500) {
-	    LOG_I( PHY, "[initial_sync] No cell synchronization found, abandoning\n" );
-	    FILE *fd;
-	    if ((fd = fopen("rxsig_frame0.dat","w"))!=NULL) {
-	      fwrite((void*)&UE->common_vars.rxdata[0][0],
-		     sizeof(int32_t),
-		     10*UE->frame_parms.samples_per_tti,
-		     fd);
-	      LOG_I(PHY,"Dummping Frame ... bye bye \n");
-	      fclose(fd);
-	      exit(0);
-	    }
-	    mac_xface->macphy_exit("No cell synchronization found, abandoning");
-	    return &UE_thread_synch_retval; // not reached
-	  }
-	}
-	else {
-	  
-	}
-        LOG_I( PHY, "[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n", 
-	       freq_offset,
-               UE->rx_total_gain_dB,
-               downlink_frequency[0][0]+freq_offset,
-               downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
-
-	for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-	  openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
-	  openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
-	  
-	  openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
-	  
-	  if (UE->UE_scan_carrier==1) {
-	    openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-	  }
-	}
-
-	UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
-	    
-      }// initial_sync=0
-
-      break;
-
-    case si:
-    default:
-      break;
     }
 
+    while (oai_exit==0) {
 
-    if (pthread_mutex_lock(&UE->proc.mutex_synch) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE synch\n" );
-      exit_fun("noting to add");
-      return &UE_thread_synch_retval;
-    }
-
-    // indicate readiness
-    UE->proc.instance_cnt_synch--;
-
-    if (pthread_mutex_unlock(&UE->proc.mutex_synch) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE synch\n" );
-      exit_fun("noting to add");
-      return &UE_thread_synch_retval;
-    }
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 0 );
-  }  // while !oai_exit
-
-  return &UE_thread_synch_retval;
-}
-
+        if (pthread_mutex_lock(&UE->proc.mutex_synch) != 0) {
+            LOG_E( PHY, "[SCHED][UE] error locking mutex for UE initial synch thread\n" );
+            exit_fun("noting to add");
+            return &UE_thread_synch_retval;
+        }
 
 
-/*!
- * \brief This is the UE thread for RX subframe n and TX subframe n+4.
- * This thread performs the phy_procedures_UE_RX() on every received slot.
- * then, if TX is enabled it performs TX for n+4. 
- * \param arg is a pointer to a \ref PHY_VARS_UE structure.
- * \returns a pointer to an int. The storage is not on the heap and must not be freed.
- */
+        while (UE->proc.instance_cnt_synch < 0) {
+            // the thread waits here most of the time
+            pthread_cond_wait( &UE->proc.cond_synch, &UE->proc.mutex_synch );
+        }
 
-static void *UE_thread_rxn_txnp4(void *arg)
-{
-  static int UE_thread_rxtx_retval;
-  UE_rxtx_proc_t *proc = (UE_rxtx_proc_t *)arg;
-  int ret;
-  PHY_VARS_UE *UE=PHY_vars_UE_g[0][proc->CC_id];
-  proc->instance_cnt_rxtx=-1;
+        if (pthread_mutex_unlock(&UE->proc.mutex_synch) != 0) {
+            LOG_E( PHY, "[SCHED][eNB] error unlocking mutex for UE Initial Synch thread\n" );
+            exit_fun("nothing to add");
+            return &UE_thread_synch_retval;
+        }
 
+        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 1 );
 
-#ifdef DEADLINE_SCHEDULER
+        switch (sync_mode) {
+        case pss:
+            LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
+            lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
+            current_offset += 20000000; // increase by 20 MHz
 
-  struct sched_attr attr;
-  unsigned int flags = 0;
+            if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
+                current_band++;
+                current_offset=0;
+            }
 
-  attr.size = sizeof(attr);
-  attr.sched_flags = 0;
-  attr.sched_nice = 0;
-  attr.sched_priority = 0;
+            if (current_band==bands_to_scan.nbands) {
+                current_band=0;
+                oai_exit=1;
+            }
 
-  // This creates a .5ms reservation every 1ms period
-  attr.sched_policy   = SCHED_DEADLINE;
-  attr.sched_runtime  = 900000;  // each rx thread requires 1ms to finish its job
-  attr.sched_deadline = 1000000; // each rx thread will finish within 1ms
-  attr.sched_period   = 1000000; // each rx thread has a period of 1ms from the starting point
+            for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+                downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
+                uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].ul_min-bands_to_scan.band_info[0].dl_min + current_offset;
 
-  if (sched_setattr(0, &attr, flags) < 0 ) {
-    perror("[SCHED] UE_thread_rxtx : sched_setattr failed\n");
-    return &UE_thread_rxtx_retval;
-  }
+                openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+                openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+                openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+                if (UE->UE_scan_carrier) {
+                    openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+                }
 
-#else
-  int policy, s, j;
-  struct sched_param sparam;
-  char cpu_affinity[1024];
-  cpu_set_t cpuset;
-
-  /* Set affinity mask to include CPUs 1 to MAX_CPUS */
-  /* CPU 0 is reserved for UHD threads */
-  CPU_ZERO(&cpuset);
-
-  #ifdef CPU_AFFINITY
-  if (get_nprocs() >2)
-  {
-    for (j = 1; j < get_nprocs(); j++)
-      CPU_SET(j, &cpuset);
-
-    s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-    if (s != 0)
-    {
-      perror( "pthread_setaffinity_np");
-      exit_fun("Error setting processor affinity");
-    }
-  }
-  #endif
-
-  /* Check the actual affinity mask assigned to the thread */
-
-  s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  if (s != 0)
-  {
-    perror( "pthread_getaffinity_np");
-    exit_fun("Error getting processor affinity ");
-  }
-  memset(cpu_affinity, 0 , sizeof(cpu_affinity));
-  for (j = 0; j < CPU_SETSIZE; j++)
-  if (CPU_ISSET(j, &cpuset))
-  {  
-     char temp[1024];
-     sprintf(temp, " CPU_%d ", j);    
-     strcat(cpu_affinity, temp);
-  }
-
-  memset(&sparam, 0 , sizeof (sparam));
-  sparam.sched_priority = sched_get_priority_max(SCHED_FIFO)-1;
-  policy = SCHED_FIFO ; 
-  
-  s = pthread_setschedparam(pthread_self(), policy, &sparam);
-  if (s != 0)
-     {
-     perror("pthread_setschedparam : ");
-     exit_fun("Error setting thread priority");
-     }
-  s = pthread_getschedparam(pthread_self(), &policy, &sparam);
-  if (s != 0)
-   {
-     perror("pthread_getschedparam : ");
-     exit_fun("Error getting thread priority");
-
-   }
-
-  LOG_I( HW, "[SCHED][UE] Started UE RX thread on CPU %d TID %ld , sched_policy = %s, priority = %d, CPU Affinity = %s \n", (int)sched_getcpu(), gettid(),
-                   (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
-                   (policy == SCHED_RR)    ? "SCHED_RR" :
-                   (policy == SCHED_OTHER) ? "SCHED_OTHER" :
-                   "???",
-                   (int) sparam.sched_priority, cpu_affinity);
+            }
 
+            break;
+
+        case pbch:
+
+            LOG_I(PHY,"[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
+            if (initial_sync( UE, UE->mode ) == 0) {
+
+                hw_slot_offset = (UE->rx_offset<<1) / UE->frame_parms.samples_per_tti;
+                LOG_I( HW, "Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %d (DL %u, UL %u), UE_scan_carrier %d\n",
+                       hw_slot_offset,
+                       freq_offset,
+                       UE->rx_total_gain_dB,
+                       downlink_frequency[0][0]+freq_offset,
+                       downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset,
+                       UE->UE_scan_carrier );
+
+                if (UE->UE_scan_carrier == 1) {
+
+                    UE->UE_scan_carrier = 0;
+                    // rerun with new cell parameters and frequency-offset
+                    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+                        openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+                        openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= UE->common_vars.freq_offset;
+                        openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =  openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
+                        downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
+                        freq_offset=0;
+                    }
+
+                    // reconfigure for potentially different bandwidth
+                    switch(UE->frame_parms.N_RB_DL) {
+                    case 6:
+                        openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
+                        openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
+                        openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
+                        //            openair0_cfg[0].rx_gain[0] -= 12;
+                        break;
+                    case 25:
+                        openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
+                        openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
+                        openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
+                        //            openair0_cfg[0].rx_gain[0] -= 6;
+                        break;
+                    case 50:
+                        openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
+                        openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
+                        openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
+                        //            openair0_cfg[0].rx_gain[0] -= 3;
+                        break;
+                    case 100:
+                        openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
+                        openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
+                        openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
+                        //            openair0_cfg[0].rx_gain[0] -= 0;
+                        break;
+                    }
+
+                    UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
+                    //UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
+                    UE->rfdevice.trx_stop_func(&UE->rfdevice);
+                    sleep(1);
+                    init_frame_parms(&UE->frame_parms,1);
+                    if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
+                        LOG_E(HW,"Could not start the device\n");
+                        oai_exit=1;
+                    }
+                } else {
+                    UE->is_synchronized = 1;
+
+                    if( UE->mode == rx_dump_frame ) {
+                        FILE *fd;
+                        if ((UE->proc.proc_rxtx[0].frame_rx&1) == 0) {  // this guarantees SIB1 is present
+                            if ((fd = fopen("rxsig_frame0.dat","w")) != NULL) {
+                                fwrite((void*)&UE->common_vars.rxdata[0][0],
+                                       sizeof(int32_t),
+                                       10*UE->frame_parms.samples_per_tti,
+                                       fd);
+                                LOG_I(PHY,"Dummping Frame ... bye bye \n");
+                                fclose(fd);
+                                exit(0);
+                            } else {
+                                LOG_E(PHY,"Cannot open file for writing\n");
+                                exit(0);
+                            }
+                        } else {
+                            UE->is_synchronized = 0;
+                        }
+                    }
+                }
+            } else {
+                // initial sync failed
+                // calculate new offset and try again
+                if (UE->UE_scan_carrier == 1) {
+                    if (freq_offset >= 0) {
+                        freq_offset += 100;
+                        freq_offset *= -1;
+                    } else {
+                        freq_offset *= -1;
+                    }
+
+                    if (abs(freq_offset) > 7500) {
+                        LOG_I( PHY, "[initial_sync] No cell synchronization found, abandoning\n" );
+                        FILE *fd;
+                        if ((fd = fopen("rxsig_frame0.dat","w"))!=NULL) {
+                            fwrite((void*)&UE->common_vars.rxdata[0][0],
+                                   sizeof(int32_t),
+                                   10*UE->frame_parms.samples_per_tti,
+                                   fd);
+                            LOG_I(PHY,"Dummping Frame ... bye bye \n");
+                            fclose(fd);
+                            exit(0);
+                        }
+                        mac_xface->macphy_exit("No cell synchronization found, abandoning");
+                        return &UE_thread_synch_retval; // not reached
+                    }
+                } else {
+
+                }
+                LOG_I( PHY, "[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
+                       freq_offset,
+                       UE->rx_total_gain_dB,
+                       downlink_frequency[0][0]+freq_offset,
+                       downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
+
+                for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+                    openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
+                    openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
+
+                    openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+
+                    if (UE->UE_scan_carrier==1) {
+                        openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+                    }
+                }
+
+                UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
+
+            }// initial_sync=0
+
+            break;
+
+        case si:
+        default:
+            break;
+        }
 
-#endif
 
-  // Lock memory from swapping. This is a process wide call (not constraint to this thread).
-  mlockall(MCL_CURRENT | MCL_FUTURE);
+        if (pthread_mutex_lock(&UE->proc.mutex_synch) != 0) {
+            LOG_E( PHY, "[SCHED][UE] error locking mutex for UE synch\n" );
+            exit_fun("noting to add");
+            return &UE_thread_synch_retval;
+        }
 
-  printf("waiting for sync (UE_thread_rxn_txnp4)\n");
+        // indicate readiness
+        UE->proc.instance_cnt_synch--;
 
-  pthread_mutex_lock(&sync_mutex);
-  printf("Locked sync_mutex, waiting (UE_thread_rxn_txnp4)\n");
+        if (pthread_mutex_unlock(&UE->proc.mutex_synch) != 0) {
+            LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE synch\n" );
+            exit_fun("noting to add");
+            return &UE_thread_synch_retval;
+        }
 
-  while (sync_var<0)
-    pthread_cond_wait(&sync_cond, &sync_mutex);
+        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 0 );
+    }  // while !oai_exit
 
-#define THREAD_NAME_LEN 16
-  char threadname[THREAD_NAME_LEN];
-  ret = pthread_getname_np(proc->pthread_rxtx, threadname, THREAD_NAME_LEN);
-  if (ret != 0)
-  {
-   perror("pthread_getname_np : ");
-   exit_fun("Error getting thread name");
-  }
+    return &UE_thread_synch_retval;
+}
 
-  pthread_mutex_unlock(&sync_mutex);
-  printf("unlocked sync_mutex, waiting (UE_thread_rxtx)\n");
 
-  printf("Starting UE RXN_TXNP4 thread (%s)\n", threadname);
 
-  while (!oai_exit) {
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_COND_WAIT0+(proc->subframe_rx&1), 1 );
-    if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
-      exit_fun("nothing to add");
-      return &UE_thread_rxtx_retval;
-    }
+/*!
+ * \brief This is the UE thread for RX subframe n and TX subframe n+4.
+ * This thread performs the phy_procedures_UE_RX() on every received slot.
+ * then, if TX is enabled it performs TX for n+4.
+ * \param arg is a pointer to a \ref PHY_VARS_UE structure.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
 
-    while (proc->instance_cnt_rxtx < 0) {
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX0+(proc->subframe_rx&1), 1 );
-      // most of the time, the thread is waiting here
-      pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx );
-    }
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX0+(proc->subframe_rx&1), 0 );
+static void *UE_thread_rxn_txnp4(void *arg) {
+    static __thread int UE_thread_rxtx_retval;
+    UE_rxtx_proc_t *proc = (UE_rxtx_proc_t *)arg;
+    int ret;
+    PHY_VARS_UE *UE=PHY_vars_UE_g[0][proc->CC_id];
+
+    static long long __thread instance_cnt_rxtx=-1;
+    proc->subframe_rx=proc->sub_frame_start;
+
+    char threadName[256]= {0};
+    sprintf(threadName,"UE_thread_rxn_txnp4_%d",proc->sub_frame_start);
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(proc->sub_frame_start+1, &cpuset);
+    init_thread(900000,1000000 , 40, &cpuset,//sched_get_priority_max(SCHED_FIFO)-1,
+                threadName);
+
+    while (!oai_exit) {
+        // Wait Rx data to process are available
+        AssertFatal(pthread_mutex_lock(&proc->mutex_rxtx) ==0,"");
+        pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx );
+        if ( (instance_cnt_rxtx+proc->sub_frame_step)%10 != proc->subframe_rx &&  instance_cnt_rxtx!=-1 )
+            LOG_W(PHY,"REAL TIME NOT MATCHED: missed a sub-frame: expecting %d, got %d\n",
+                  (instance_cnt_rxtx+proc->sub_frame_step)%10, proc->subframe_rx);
+        instance_cnt_rxtx=proc->subframe_rx;
+        AssertFatal(pthread_mutex_unlock(&proc->mutex_rxtx) ==0,"");
+
+        static __thread Meas t2= {0}, t3= {0};
+        unsigned long long current=rdtsc();
+        updateTimes(proc->gotIQs, &t2, 10000, "saif: Delay to wake up UE_Thread_Rx (case 2)");
+
+        // Process Rx data for one sub-frame
+        lte_subframe_t sf_type = subframe_select( &UE->frame_parms, proc->subframe_rx);
+        if ((sf_type == SF_DL) ||
+                (UE->frame_parms.frame_type == FDD) ||
+                (sf_type == SF_S)) {
+
+            if (UE->frame_parms.frame_type == TDD) {
+                LOG_D(PHY, "%s,TDD%d,%s: calling UE_RX\n",
+                      threadName,
+                      UE->frame_parms.tdd_config,
+                      (sf_type==SF_DL? "SF_DL" :
+                       (sf_type==SF_UL? "SF_UL" :
+                        (sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
+            } else {
+                LOG_D(PHY, "%s,%s,%s: calling UE_RX\n",
+                      threadName,
+                      (UE->frame_parms.frame_type==FDD? "FDD":
+                       (UE->frame_parms.frame_type==TDD? "TDD":"UNKNOWN_DUPLEX_MODE")),
+                      (sf_type==SF_DL? "SF_DL" :
+                       (sf_type==SF_UL? "SF_UL" :
+                        (sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
+            }
+            phy_procedures_UE_RX( UE, proc, 0, 0, UE->mode, no_relay, NULL );
+        }
 
-    if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
-      exit_fun("nothing to add");
-      return &UE_thread_rxtx_retval;
-    }
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_COND_WAIT0+(proc->subframe_rx&1), 0 );
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX0+(proc->subframe_rx&1), 1 );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_UE+(proc->subframe_rx&1), proc->subframe_rx );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_UE+(proc->subframe_tx&1), proc->subframe_tx );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_UE+(proc->subframe_rx&1), proc->frame_rx );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_UE+(proc->subframe_tx&1), proc->frame_tx );
-
-    lte_subframe_t sf_type = subframe_select( &UE->frame_parms, proc->subframe_rx);
-    if ((sf_type == SF_DL) ||
-        (UE->frame_parms.frame_type == FDD) ||
-        (sf_type == SF_S)) {
-    
-      if (UE->frame_parms.frame_type == TDD) {
-      LOG_D(PHY, "%s,TDD%d,%s: calling UE_RX\n",
-          threadname,
-          UE->frame_parms.tdd_config,
-          (sf_type==SF_DL? "SF_DL" :
-          (sf_type==SF_UL? "SF_UL" :
-          (sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
-      } else {
-        LOG_D(PHY, "%s,%s,%s: calling UE_RX\n",
-            threadname,
-            (UE->frame_parms.frame_type==FDD? "FDD":
-            (UE->frame_parms.frame_type==TDD? "TDD":"UNKNOWN_DUPLEX_MODE")),
-            (sf_type==SF_DL? "SF_DL" :
-            (sf_type==SF_UL? "SF_UL" :
-            (sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
-      }
-      phy_procedures_UE_RX( UE, proc, 0, 0, UE->mode, no_relay, NULL );
-    }
-    
-    if (UE->mac_enabled==1) {
-
-      ret = mac_xface->ue_scheduler(UE->Mod_id,
-          proc->frame_rx,
-          proc->subframe_rx,
-          proc->frame_tx,
-          proc->subframe_tx,
-          subframe_select(&UE->frame_parms,proc->subframe_tx),
-          0,
-          0/*FIXME CC_id*/);
-      
-      if (ret == CONNECTION_LOST) {
-	LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u RRC Connection lost, returning to PRACH\n",
-	       UE->Mod_id, proc->frame_rx, proc->subframe_tx );
-	UE->UE_mode[0] = PRACH;
-      } else if (ret == PHY_RESYNCH) {
-	LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u RRC Connection lost, trying to resynch\n",
-	       UE->Mod_id, proc->frame_rx, proc->subframe_tx );
-	UE->UE_mode[0] = RESYNCH;
-      } else if (ret == PHY_HO_PRACH) {
-	LOG_I( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u, return to PRACH and perform a contention-free access\n",
-	       UE->Mod_id, proc->frame_rx, proc->subframe_tx );
-	UE->UE_mode[0] = PRACH;
-      }
-    }
+        if (UE->mac_enabled==1) {
+
+            ret = mac_xface->ue_scheduler(UE->Mod_id,
+                                          proc->frame_rx,
+                                          proc->subframe_rx,
+                                          proc->frame_tx,
+                                          proc->subframe_tx,
+                                          subframe_select(&UE->frame_parms,proc->subframe_tx),
+                                          0,
+                                          0/*FIXME CC_id*/);
+            if ( ret != CONNECTION_OK) {
+                char *txt;
+                switch (ret) {
+                case CONNECTION_LOST:
+                    txt="RRC Connection lost, returning to PRACH";
+                    break;
+                case PHY_RESYNCH:
+                    txt="RRC Connection lost, trying to resynch";
+                    break;
+                case RESYNCH:
+                    txt="return to PRACH and perform a contention-free access";
+                    break;
+                default:
+                    txt="UNKNOWN RETURN CODE";
+                };
+                LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u %s\n",
+                       UE->Mod_id, proc->frame_rx, proc->subframe_tx,txt );
+            }
+        }
+        // Prepare the future Tx data
 
-    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
-	(UE->frame_parms.frame_type == FDD) ) {
+        if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
+                (UE->frame_parms.frame_type == FDD) )
+            if (UE->mode != loop_through_memory)
+                phy_procedures_UE_TX(UE,proc,0,0,UE->mode,no_relay);
 
-      if (UE->mode != loop_through_memory) {
-	phy_procedures_UE_TX(UE,proc,0,0,UE->mode,no_relay);
-      }
-    }
 
-    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
-  (UE->frame_parms.frame_type == TDD)) {
+        if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
+                (UE->frame_parms.frame_type == TDD))
+            if (UE->mode != loop_through_memory)
+                phy_procedures_UE_S_TX(UE,0,0,no_relay);
+        updateTimes(current, &t3, 10000, "saif: Delay to process sub-frame (case 3)");
 
-      if (UE->mode != loop_through_memory) {
-  phy_procedures_UE_S_TX(UE,0,0,no_relay);
-      }
     }
 
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX0+(proc->subframe_rx&1), 0 );
-
-    
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_DECREMENT0+(proc->subframe_rx&1), 1 );
-    if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
-      exit_fun("noting to add");
-      return &UE_thread_rxtx_retval;
-    }
-    
-    proc->instance_cnt_rxtx--;
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE_INST_CNT_RX, proc->instance_cnt_rxtx);
-    
-    if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
-      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXTX\n" );
-      exit_fun("noting to add");
-      return &UE_thread_rxtx_retval;
-    }
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_DECREMENT0+(proc->subframe_rx&1), 0 );
-  }
-  
-  // thread finished
-  return &UE_thread_rxtx_retval;
+// thread finished
+    return &UE_thread_rxtx_retval;
 }
 
-
-
-
-
 #define RX_OFF_MAX 10
 #define RX_OFF_MIN 5
 #define RX_OFF_MID ((RX_OFF_MAX+RX_OFF_MIN)/2)
@@ -870,890 +836,307 @@ static void *UE_thread_rxn_txnp4(void *arg)
 
 void *UE_thread(void *arg) {
 
-  static int UE_thread_retval;
-  PHY_VARS_UE *UE = PHY_vars_UE_g[0][0];
-  //  int tx_enabled = 0;
-  unsigned int rxs,txs;
-  int dummy_rx[UE->frame_parms.nb_antennas_rx][UE->frame_parms.samples_per_tti] __attribute__((aligned(32)));
-  openair0_timestamp timestamp,timestamp1;
-  void* rxp[2], *txp[2];
-
-#ifdef NAS_UE
-  MessageDef *message_p;
-#endif
-
-  int start_rx_stream = 0;
-  int rx_off_diff = 0;
-  int rx_correction_timer = 0;
-  int i;
-
-#ifdef DEADLINE_SCHEDULER
-
-  struct sched_attr attr;
-  unsigned int flags = 0;
-
-  attr.size = sizeof(attr);
-  attr.sched_flags = 0;
-  attr.sched_nice = 0;
-  attr.sched_priority = 0;//sched_get_priority_max(SCHED_DEADLINE);
-
-  // This creates a .5 ms  reservation
-  attr.sched_policy = SCHED_DEADLINE;
-  attr.sched_runtime  = 100000;
-  attr.sched_deadline = 500000;
-  attr.sched_period   = 500000;
-
-  if (sched_setattr(0, &attr, flags) < 0 ) {
-    perror("[SCHED] main eNB thread: sched_setattr failed\n");
-    exit_fun("Nothing to add");
-    return &UE_thread_retval;
-  }
-  LOG_I(HW,"[SCHED][eNB] eNB main deadline thread %lu started on CPU %d\n",
-        (unsigned long)gettid(), sched_getcpu());
-
-#else
-  struct sched_param sp;
-  sp.sched_priority = sched_get_priority_max(SCHED_FIFO);
-  pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp);
-#endif
-
-  // Lock memory from swapping. This is a process wide call (not constraint to this thread).
-  mlockall(MCL_CURRENT | MCL_FUTURE);
-
-  printf("waiting for sync (UE_thread)\n");
-  pthread_mutex_lock(&sync_mutex);
-  printf("Locked sync_mutex, waiting (UE_thread)\n");
-
-  while (sync_var<0)
-    pthread_cond_wait(&sync_cond, &sync_mutex);
+    PHY_VARS_UE *UE = PHY_vars_UE_g[0][0];
+    //  int tx_enabled = 0;
+    int dummy_rx[UE->frame_parms.nb_antennas_rx][UE->frame_parms.samples_per_tti] __attribute__((aligned(32)));
+    openair0_timestamp timestamp,timestamp1;
+    void* rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
+    int start_rx_stream = 0;
+    int i;
 
-  pthread_mutex_unlock(&sync_mutex);
-  printf("unlocked sync_mutex, waiting (UE_thread)\n");
-
-  printf("starting UE thread\n");
-
-#ifdef NAS_UE
-  message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
-  itti_send_msg_to_task (TASK_NAS_UE, INSTANCE_DEFAULT, message_p);
-#endif 
-
-  while (!oai_exit) {
-    
-    if (UE->is_synchronized == 0) {
-      
-      if (pthread_mutex_lock(&UE->proc.mutex_synch) != 0) {
-	LOG_E( PHY, "[SCHED][UE] verror locking mutex for UE initial synch thread\n" );
-	exit_fun("nothing to add");
-	return &UE_thread_retval;
-      }
-      
-      int instance_cnt_synch = UE->proc.instance_cnt_synch;
-      
-      if (pthread_mutex_unlock(&UE->proc.mutex_synch) != 0) {
-	LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE initial synch thread\n" );
-	exit_fun("nothing to add");
-	return &UE_thread_retval;
-      }
-      
-      if (instance_cnt_synch < 0) {  // we can invoke the synch
-	// grab 10 ms of signal and wakeup synch thread
-	for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-	  rxp[i] = (void*)&rxdata[i][0];
-      
-	if (UE->mode != loop_through_memory) {
-	  rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					   &timestamp,
-					   rxp,
-					   UE->frame_parms.samples_per_tti*10,
-					   UE->frame_parms.nb_antennas_rx);
-	  
-	  
-	  if (rxs!=UE->frame_parms.samples_per_tti*10) {
-	    LOG_E(PHY, "problem in rx 1! want #samples=%d but got only %d!\n", UE->frame_parms.samples_per_tti*10, rxs);
-	    exit_fun("problem in rx 1");
-	    return &UE_thread_retval;
-	  }
-	}
-
-	instance_cnt_synch = ++UE->proc.instance_cnt_synch;
-	if (instance_cnt_synch == 0) {
-	  if (pthread_cond_signal(&UE->proc.cond_synch) != 0) {
-	    LOG_E( PHY, "[SCHED][UE] ERROR pthread_cond_signal for UE sync thread\n" );
-	    exit_fun("nothing to add");
-	    return &UE_thread_retval;
-	  }
-	} else {
-	  LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
-	  exit_fun("nothing to add");
-	  return &UE_thread_retval;
-	}
-      } // 
-      else {
-	// grab 10 ms of signal into dummy buffer
-
-	if (UE->mode != loop_through_memory) {
-	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-	    rxp[i] = (void*)&dummy_rx[i][0];
-	  for (int sf=0;sf<10;sf++) {
-	    //	    printf("Reading dummy sf %d\n",sf);
-	    rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					     &timestamp,
-					     rxp,
-					     UE->frame_parms.samples_per_tti,
-					     UE->frame_parms.nb_antennas_rx);
-
-	    if (rxs!=UE->frame_parms.samples_per_tti){
-	      LOG_E(PHY, "problem in rx 2! want #samples=%d but got only %d!\n", UE->frame_parms.samples_per_tti, rxs);
-	      exit_fun("problem in rx 2");
-	      return &UE_thread_retval;
-	    }
-
-	  }
-	}
-      }
-      
-    } // UE->is_synchronized==0
-    else {
-      if (start_rx_stream==0) {
-	start_rx_stream=1;
-	if (UE->mode != loop_through_memory) {
-
-	  if (UE->no_timing_correction==0) {
-	    LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
-	    rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					     &timestamp,
-					     (void**)rxdata,
-					     UE->rx_offset,
-					     UE->frame_parms.nb_antennas_rx);
-	    if (rxs != UE->rx_offset) {
-	      LOG_E(PHY, "problem in rx 3! want #samples=%d but got only %d!\n", UE->rx_offset, rxs);
-	      exit_fun("problem in rx 3!");
-	      return &UE_thread_retval;
-	    }
-	  }
-	  UE->rx_offset=0;
-	  UE->proc.proc_rxtx[0].frame_rx++;
-	  UE->proc.proc_rxtx[1].frame_rx++;
-
-	  // read in first symbol
-	  rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					   &timestamp,
-					   (void**)rxdata,
-					   UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
-					   UE->frame_parms.nb_antennas_rx);
-    if (rxs != (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0)) {
-      LOG_E(PHY, "problem in rx 4! want #samples=%d but got only %d!\n", UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0, rxs);
-      exit_fun("problem in rx 4!");
-      return &UE_thread_retval;
-    }
-	  slot_fep(UE,
-		   0,
-		   0,
-		   0,
-		   0,
-		   0);
-	  if (rxs != UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0) {
-	    exit_fun("problem in rx");
-	    return &UE_thread_retval;
-	  }
-	} //UE->mode != loop_through_memory
-	else
-	  rt_sleep_ns(1000000);
-
-      }// start_rx_stream==0
-      else {
-	//UE->proc.proc_rxtx[0].frame_rx++;
-	//UE->proc.proc_rxtx[1].frame_rx++;
-	
-	for (int sf=0;sf<10;sf++) {
-	  for (i=0; i<UE->frame_parms.nb_antennas_rx; i++) 
-	    rxp[i] = (void*)&rxdata[i][UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0+(sf*UE->frame_parms.samples_per_tti)];
-	  // grab signal for subframe
-	  if (UE->mode != loop_through_memory) {
-	    if (sf<9) {
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
-	      rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					       &timestamp,
-					       rxp,
-					       UE->frame_parms.samples_per_tti,
-					       UE->frame_parms.nb_antennas_rx);
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
-	      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS, rxs );
-	      if (rxs != UE->frame_parms.samples_per_tti) {
-	        LOG_E(PHY, "problem in rx 5! want #samples=%d but got only %d!\n", UE->frame_parms.samples_per_tti, rxs);
-	        exit_fun("problem in rx 5!");
-	        return &UE_thread_retval;
-	      }
-	      
-	      // prepare tx buffer pointers
-	      for (i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-		txp[i] = (void*)&UE->common_vars.txdata[i][((sf+2)%10)*UE->frame_parms.samples_per_tti];
-	      
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );
-	      txs = UE->rfdevice.trx_write_func(&UE->rfdevice,
-						timestamp+
-						(2*UE->frame_parms.samples_per_tti) -
-						UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
-						openair0_cfg[0].tx_sample_advance,
-						txp,
-						UE->frame_parms.samples_per_tti,
-						UE->frame_parms.nb_antennas_tx,
-						1);
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
-	      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS, rxs );
-        if (txs !=  UE->frame_parms.samples_per_tti) {
-           LOG_E(PHY,"TX : Timeout (sent %d/%d)\n",txs, UE->frame_parms.samples_per_tti);
-           exit_fun( "problem transmitting samples" );
-        }
-	    }
-	    
-	    else {
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9, 1 );
-	      rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					       &timestamp,
-					       rxp,
-					       UE->frame_parms.samples_per_tti-UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0,
-					       UE->frame_parms.nb_antennas_rx);
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9, 0 );
-	      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS, rxs );
-        if (rxs != (UE->frame_parms.samples_per_tti-UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0)) {
-          LOG_E(PHY, "problem in rx 6! want #samples=%d but got only %d!\n", UE->frame_parms.samples_per_tti-UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0, rxs);
-          exit_fun("problem in rx 6!");
-          return &UE_thread_retval;
-        }
-
-	      // prepare tx buffer pointers
-	      for (i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-		txp[i] = (void*)&UE->common_vars.txdata[i][((sf+2)%10)*UE->frame_parms.samples_per_tti];
-	      
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_SF9, 1 );
-	      txs = UE->rfdevice.trx_write_func(&UE->rfdevice,
-						timestamp+
-						(2*UE->frame_parms.samples_per_tti) -
-						UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
-						openair0_cfg[0].tx_sample_advance,
-						txp,
-						UE->frame_parms.samples_per_tti - rx_off_diff,
-						UE->frame_parms.nb_antennas_tx,
-						1);
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_SF9, 0 );
-	      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS, rxs );
-              if (txs !=  UE->frame_parms.samples_per_tti - rx_off_diff) {
-                 LOG_E(PHY,"TX : Timeout (sent %d/%d)\n",txs, UE->frame_parms.samples_per_tti-rx_off_diff);
-                 exit_fun( "problem transmitting samples" );
-              }
-
-        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9, 1 );
-	      // read in first symbol of next frame and adjust for timing drift
-	      rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					       &timestamp1,
-					       (void**)rxdata,
-					       UE->frame_parms.ofdm_symbol_size + UE->frame_parms.nb_prefix_samples0 - rx_off_diff,
-					       UE->frame_parms.nb_antennas_rx);
-	      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9, 0 );
-	      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS, rxs );
-        if (rxs != (UE->frame_parms.ofdm_symbol_size + UE->frame_parms.nb_prefix_samples0 - rx_off_diff)) {
-          LOG_E(PHY, "problem in rx 7! want #samples=%d but got only %d! rx_off_diff=%d\n", UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0 - rx_off_diff, rxs, rx_off_diff);
-          exit_fun("problem in rx 7!");
-          return &UE_thread_retval;
-        }
-        rx_off_diff = 0;
-	    }
-	  }
-	  // operate on thread sf mod 2
-	  UE_rxtx_proc_t *proc = &UE->proc.proc_rxtx[sf&1];
-
-	  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT0+(proc->subframe_rx&1), 1 );
-	  // lock mutex
-	  if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
-	    LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RX\n" );
-	    exit_fun("nothing to add");
-	    return &UE_thread_retval;
-	  }
-	  // increment instance count and change proc subframe/frame variables
-	  int instance_cnt_rxtx = ++proc->instance_cnt_rxtx;
-	  if(sf == 0)
-	  {
-	     UE->proc.proc_rxtx[0].frame_rx++;
-	     UE->proc.proc_rxtx[1].frame_rx++;
-	  }
-	  proc->subframe_rx=sf;
-	  proc->subframe_tx=(sf+4)%10;
-	  proc->frame_tx = proc->frame_rx + ((proc->subframe_rx>5)?1:0);
-	  proc->timestamp_tx = timestamp+(4*UE->frame_parms.samples_per_tti)-UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
-
-	  /*
-	  if (sf != (timestamp/UE->frame_parms.samples_per_tti)%10) {
-	    LOG_E(PHY,"steady-state UE_thread error : frame_rx %d, subframe_rx %d, frame_tx %d, subframe_tx %d, rx subframe %d\n",proc->frame_rx,proc->subframe_rx,proc->frame_tx,proc->subframe_tx,(timestamp/UE->frame_parms.samples_per_tti)%10);
-	    exit(-1);
-	  }
-	  */
-	  if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
-	    LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RX\n" );
-	    exit_fun("nothing to add");
-	    return &UE_thread_retval;
-	  }
-	  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT0+(proc->subframe_rx&1), 0 );
-
-
-	  if (instance_cnt_rxtx == 0) {
-	    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX, 1 );
-	    if (pthread_cond_signal(&proc->cond_rxtx) != 0) {
-	      LOG_E( PHY, "[SCHED][UE] ERROR pthread_cond_signal for UE RX thread\n" );
-	      exit_fun("nothing to add");
-	      return &UE_thread_retval;
-	    }
-	    LOG_D(PHY, "firing up rxtx_thread[%d] at subframe %d\n", sf&1, sf);
-
-	    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX, 0 );
-
-	  } else {
-	    LOG_E( PHY, "[SCHED][UE] UE RX thread busy (IC %d)!!\n", instance_cnt_rxtx);
-	    if (instance_cnt_rxtx > 2) {
-	      sleep(1);
-	      exit_fun("instance_cnt_rxtx > 2");
-	      return &UE_thread_retval;
-	    }
-	  }
-	  if (UE->mode == loop_through_memory) {
-	    printf("Processing subframe %d",proc->subframe_rx);
-	    getchar();
-	  }
-	}// for sf=0..10
-	if ((UE->rx_offset<(5*UE->frame_parms.samples_per_tti)) &&
-	    (UE->rx_offset > RX_OFF_MIN) && 
-	    (rx_correction_timer == 0)) {
-	  rx_off_diff = -UE->rx_offset + RX_OFF_MIN;
-	  LOG_D(PHY,"UE->rx_offset %d > %d, diff %d\n",UE->rx_offset,RX_OFF_MIN,rx_off_diff);
-	  rx_correction_timer = 5;
-	} else if ((UE->rx_offset>(5*UE->frame_parms.samples_per_tti)) && 
-		   (UE->rx_offset < ((10*UE->frame_parms.samples_per_tti)-RX_OFF_MIN)) &&
-		   (rx_correction_timer == 0)) {   // moving to the left so drop rx_off_diff samples
-	  rx_off_diff = 10*UE->frame_parms.samples_per_tti - RX_OFF_MIN - UE->rx_offset;
-	  LOG_D(PHY,"UE->rx_offset %d < %d, diff %d\n",UE->rx_offset,10*UE->frame_parms.samples_per_tti-RX_OFF_MIN,rx_off_diff);
-	  
-	  rx_correction_timer = 5;
-	}
-	
-	if (rx_correction_timer>0)
-	  rx_correction_timer--;
-      } // start_rx_stream==1
-    } // UE->is_synchronized==1
-      
-  } // while !oai_exit
- return NULL;
-} // UE_thread
-
-/*
-void *UE_thread_old(void *arg)
-{
-  UNUSED(arg)
-  static int UE_thread_retval;
-  PHY_VARS_UE *UE = PHY_vars_UE_g[0][0];
-  int spp = openair0_cfg[0].samples_per_packet;
-  int slot=1, frame=0, hw_subframe=0, rxpos=0, txpos=openair0_cfg[0].tx_scheduling_advance;
-#ifdef __AVX2__
-  int dummy[2][spp] __attribute__((aligned(32)));
-#else
-  int dummy[2][spp] __attribute__((aligned(16)));
-#endif
-  int dummy_dump = 0;
-  int tx_enabled = 0;
-  int start_rx_stream = 0;
-  int rx_off_diff = 0;
-  int rx_correction_timer = 0;
-  int first_rx = 0;
-  RTIME T0;
-  unsigned int rxs;
-  void* rxp[2];
-
-  openair0_timestamp timestamp;
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(3, &cpuset);
+    init_thread(100000, 500000, 40, &cpuset, //sched_get_priority_max(SCHED_FIFO),
+                "main UE");
 
 #ifdef NAS_UE
-  MessageDef *message_p;
+    MessageDef *message_p;
+    message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
+    itti_send_msg_to_task (TASK_NAS_UE, INSTANCE_DEFAULT, message_p);
 #endif
 
-#ifdef DEADLINE_SCHEDULER
-
-  struct sched_attr attr;
-  unsigned int flags = 0;
-
-  attr.size = sizeof(attr);
-  attr.sched_flags = 0;
-  attr.sched_nice = 0;
-  attr.sched_priority = 0;//sched_get_priority_max(SCHED_DEADLINE);
-
-  // This creates a .5 ms  reservation
-  attr.sched_policy = SCHED_DEADLINE;
-  attr.sched_runtime  = 100000;
-  attr.sched_deadline = 500000;
-  attr.sched_period   = 500000;
-
-  if (sched_setattr(0, &attr, flags) < 0 ) {
-    perror("[SCHED] main eNB thread: sched_setattr failed\n");
-    exit_fun("Nothing to add");
-    return &UE_thread_retval;
-  }
-  LOG_I(HW,"[SCHED][eNB] eNB main deadline thread %lu started on CPU %d\n",
-        (unsigned long)gettid(), sched_getcpu());
-
-#else
-  struct sched_param sp;
-  sp.sched_priority = sched_get_priority_max(SCHED_FIFO);
-  pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp);
-#endif
-
-  // Lock memory from swapping. This is a process wide call (not constraint to this thread).
-  mlockall(MCL_CURRENT | MCL_FUTURE);
-
-  printf("waiting for sync (UE_thread)\n");
-  pthread_mutex_lock(&sync_mutex);
-  printf("Locked sync_mutex, waiting (UE_thread)\n");
-
-  while (sync_var<0)
-    pthread_cond_wait(&sync_cond, &sync_mutex);
-
-  pthread_mutex_unlock(&sync_mutex);
-  printf("unlocked sync_mutex, waiting (UE_thread)\n");
+    int sub_frame=-1;
+    int cumulated_shift=0;
+    while (!oai_exit) {
+
+        if (UE->is_synchronized == 0) {
+
+            AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
+            int instance_cnt_synch = UE->proc.instance_cnt_synch;
+            AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
+
+            if (instance_cnt_synch < 0) {  // we can invoke the synch
+                // grab 10 ms of signal and wakeup synch thread
+                for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+                    rxp[i] = (void*)&rxdata[i][0];
+
+                if (UE->mode != loop_through_memory)
+                    AssertFatal( UE->frame_parms.samples_per_tti*10 ==
+                                 UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                                            &timestamp,
+                                                            rxp,
+                                                            UE->frame_parms.samples_per_tti*10,
+                                                            UE->frame_parms.nb_antennas_rx), "");
+                instance_cnt_synch = ++UE->proc.instance_cnt_synch;
+                if (instance_cnt_synch == 0) {
+                    AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
+                } else {
+                    LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
+                    exit_fun("nothing to add");
+                }
+            } //
+            else {
+                // grab 10 ms of signal into dummy buffer
+
+                if (UE->mode != loop_through_memory) {
+                    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+                        rxp[i] = (void*)&dummy_rx[i][0];
+                    for (int sf=0; sf<10; sf++) {
+                        //	    printf("Reading dummy sf %d\n",sf);
+                        AssertFatal ( UE->frame_parms.samples_per_tti ==
+                                      UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                              &timestamp,
+                                              rxp,
+                                              UE->frame_parms.samples_per_tti,
+                                              UE->frame_parms.nb_antennas_rx), "");
+
+                    }
+                }
+            }
 
-  printf("starting UE thread\n");
+        } // UE->is_synchronized==0
+        else {
+            if (start_rx_stream==0) {
+                start_rx_stream=1;
+                if (UE->mode != loop_through_memory) {
+                    if (UE->no_timing_correction==0) {
+                        LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
+                        AssertFatal(UE->rx_offset ==
+                                    UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                                               &timestamp,
+                                                               (void**)rxdata,
+                                                               UE->rx_offset,
+                                                               UE->frame_parms.nb_antennas_rx),"");
+                    }
+                    UE->rx_offset=0;
+                    UE->proc.proc_rxtx[0].frame_rx++;
+                    UE->proc.proc_rxtx[1].frame_rx++;
+
+                    // read in first symbol
+                    AssertFatal (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0 ==
+                                 UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                                            &timestamp,
+                                                            (void**)rxdata,
+                                                            UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
+                                                            UE->frame_parms.nb_antennas_rx),"");
+                    slot_fep(UE,0, 0, 0, 0, 0);
+                } //UE->mode != loop_through_memory
+                else
+                    rt_sleep_ns(1000*1000);
+
+            } else {
+                sub_frame++;
+                sub_frame%=10;
+                UE_rxtx_proc_t *proc = &UE->proc.proc_rxtx[sub_frame&1];
+
+                if (UE->mode != loop_through_memory) {
+                    for (i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+                        rxp[i] = (void*)&rxdata[i][UE->frame_parms.ofdm_symbol_size+
+                                                   UE->frame_parms.nb_prefix_samples0+
+                                                   sub_frame*UE->frame_parms.samples_per_tti];
+                    for (i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+                        txp[i] = (void*)&UE->common_vars.txdata[i][((sub_frame+2)%10)*UE->frame_parms.samples_per_tti];
+
+                    int readBlockSize, writeBlockSize;
+                    if (sub_frame<9) {
+                        readBlockSize=UE->frame_parms.samples_per_tti;
+                        writeBlockSize=UE->frame_parms.samples_per_tti;
+                    } else {
+                        int rx_off_diff;
+                        if ( UE->rx_offset< 5*UE->frame_parms.samples_per_tti )
+                            rx_off_diff = -UE->rx_offset;
+                        else   // moving to the left so drop rx_off_diff samples
+                            rx_off_diff = 10*UE->frame_parms.samples_per_tti - RX_OFF_MIN - UE->rx_offset;
+                        cumulated_shift+=rx_off_diff;
+                        if ( rx_off_diff > 10 )
+                            LOG_E (PHY,"HUGE shift %d, cumul %d\n", rx_off_diff, cumulated_shift);
+                        static __thread int printed_cumul=0;
+                        if ( abs(cumulated_shift/1000) > printed_cumul ) {
+                            LOG_W(PHY,"Shifted for 1000 samples: cumul %d\n", cumulated_shift);
+                            printed_cumul=abs(cumulated_shift/1000);
+                        }
+
+                        readBlockSize=UE->frame_parms.samples_per_tti-
+                                      UE->frame_parms.ofdm_symbol_size-
+                                      UE->frame_parms.nb_prefix_samples0;
+                        writeBlockSize=UE->frame_parms.samples_per_tti - rx_off_diff;
+                    }
+
+                    AssertFatal(readBlockSize ==
+                                UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                                           &timestamp,
+                                                           rxp,
+                                                           readBlockSize,
+                                                           UE->frame_parms.nb_antennas_rx),"");
+                    AssertFatal( writeBlockSize ==
+                                 UE->rfdevice.trx_write_func(&UE->rfdevice,
+                                         timestamp+
+                                         (2*UE->frame_parms.samples_per_tti) -
+                                         UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
+                                         openair0_cfg[0].tx_sample_advance,
+                                         txp,
+                                         writeBlockSize,
+                                         UE->frame_parms.nb_antennas_tx,
+                                         1),"");
+                    if( sub_frame==9) {
+                        // read in first symbol of next frame and adjust for timing drift
+                        int first_symbols=writeBlockSize-readBlockSize;
+                        if ( first_symbols > 0 )
+                            AssertFatal(first_symbols ==
+                                        UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                                                   &timestamp1,
+                                                                   (void**)rxdata,
+                                                                   first_symbols,
+                                                                   UE->frame_parms.nb_antennas_rx),"");
+                        if ( first_symbols <0 )
+                            LOG_E(PHY,"can't compensate: diff =%d\n", first_symbols);
+                    }
+                    unsigned long long gotIQs=rdtsc();
+                    // operate on thread sf mod 2
+                    AssertFatal(pthread_mutex_lock(&proc->mutex_rxtx) ==0,"");
+                    if(sub_frame == 0) {
+                        UE->proc.proc_rxtx[0].frame_rx++;
+                        UE->proc.proc_rxtx[1].frame_rx++;
+                    }
+                    UE->proc.proc_rxtx[0].gotIQs=gotIQs;
+                    UE->proc.proc_rxtx[1].gotIQs=gotIQs;
+                    proc->subframe_rx=sub_frame;
+                    proc->subframe_tx=(sub_frame+4)%10;
+                    proc->frame_tx = proc->frame_rx + (proc->subframe_rx>5?1:0);
+                    proc->timestamp_tx = timestamp+
+                                         (4*UE->frame_parms.samples_per_tti)-
+                                         UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
+
+                    AssertFatal (pthread_cond_signal(&proc->cond_rxtx) ==0 ,"");
+                    AssertFatal(pthread_mutex_unlock(&proc->mutex_rxtx) ==0,"");
+                    static __thread Meas t1= {0};
+                    static unsigned long long lastTime=0;
+                    if ( lastTime != 0 )
+                        updateTimes(lastTime, &t1, 20000, "saif: Delay between two IQ acquisitions (case 1)");
+                    lastTime=rdtsc();
+                    saif_meas(proc->frame_rx);
+
+                } else {
+                    printf("Processing subframe %d",proc->subframe_rx);
+                    getchar();
+                }
+            } // start_rx_stream==1
+        } // UE->is_synchronized==1
+
+    } // while !oai_exit
+    return NULL;
+}
 
-#ifdef NAS_UE
-  message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
-  itti_send_msg_to_task (TASK_NAS_UE, INSTANCE_DEFAULT, message_p);
-#endif
+/*!
+ * \brief Initialize the UE theads.
+ * Creates the UE threads:
+ * - UE_thread_rxtx0
+ * - UE_thread_rxtx1
+ * - UE_thread_synch
+ * and the locking between them.
+ */
+void init_UE_threads(int inst) {
+    PHY_VARS_UE *UE;
 
-  T0 = rt_get_time_ns();
-  first_rx = 1;
-  rxpos=0;
-
-  while (!oai_exit) {
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_HW_SUBFRAME, hw_subframe );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_HW_FRAME, frame );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_DUMMY_DUMP, dummy_dump );
-
-
-    while (rxpos < (1+hw_subframe)*UE->frame_parms.samples_per_tti) {
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
-
-#ifndef USRP_DEBUG
-
-      DevAssert( UE->frame_parms.nb_antennas_rx <= 2 );
-      void* rxp[2];
-
-      for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-        rxp[i] = (dummy_dump==0) ? (void*)&rxdata[i][rxpos] : (void*)dummy[i];
-      
-    
-      if (UE->mode != loop_through_memory) {
-	rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-				     &timestamp,
-				     rxp,
-				     spp - ((first_rx==1) ? rx_off_diff : 0),
-				     UE->frame_parms.nb_antennas_rx);
-
-	if (rxs != (spp- ((first_rx==1) ? rx_off_diff : 0))) {
-	  printf("rx error: asked %d got %d ",spp - ((first_rx==1) ? rx_off_diff : 0),rxs);
-	  if (UE->is_synchronized == 1) {
-	    exit_fun("problem in rx");
-	    return &UE_thread_retval;
-	  }
-	}
-      }
-
-      if (rx_off_diff !=0)
-	LOG_D(PHY,"frame %d, rx_offset %d, rx_off_diff %d\n",UE->frame_rx,UE->rx_offset,rx_off_diff);
-
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
-
-      // Transmit TX buffer based on timestamp from RX
-      if ((tx_enabled==1) && (UE->mode!=loop_through_memory)) {
-        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );
-
-        DevAssert( UE->frame_parms.nb_antennas_tx <= 2 );
-        void* txp[2];
-
-        for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-          txp[i] = (void*)&txdata[i][txpos];
-
-        UE->rfdevice.trx_write_func(&openair0,
-                                (timestamp+openair0_cfg[0].tx_scheduling_advance-openair0_cfg[0].tx_sample_advance),
-                                txp,
-				spp - ((first_rx==1) ? rx_off_diff : 0),
-                                UE->frame_parms.nb_antennas_tx,
-                                1);
-
-        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
-      }
-      else if (UE->mode == loop_through_memory)
-	rt_sleep_ns(1000000);
-#else
-      // define USRP_DEBUG is active
-      rt_sleep_ns(1000000);
-#endif
+    UE = PHY_vars_UE_g[inst][0];
 
-      rx_off_diff = 0;
-      first_rx = 0;
+    pthread_attr_init (&UE->proc.attr_ue);
+    pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);
 
-      rxpos += spp;
-      txpos += spp;
 
-      if (txpos >= 10*PHY_vars_UE_g[0][0]->frame_parms.samples_per_tti)
-        txpos -= 10*PHY_vars_UE_g[0][0]->frame_parms.samples_per_tti;
+    // the threads are not yet active, therefore access is allowed without locking
+    int nb_threads=2;
+    for (int i=0; i<nb_threads; i++) {
+        pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
+        pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
+        UE->proc.proc_rxtx[i].sub_frame_start=i;
+        UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
+        pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx,NULL,UE_thread_rxn_txnp4,(void*)&UE->proc.proc_rxtx[i]);
     }
+    pthread_mutex_init(&UE->proc.mutex_synch,NULL);
+    pthread_cond_init(&UE->proc.cond_synch,NULL);
+    pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void*)UE);
 
-    if (rxpos >= 10*PHY_vars_UE_g[0][0]->frame_parms.samples_per_tti)
-      rxpos -= 10*PHY_vars_UE_g[0][0]->frame_parms.samples_per_tti;
-
-    if (UE->is_synchronized == 1)  {
-      LOG_D( HW, "UE_thread: hw_frame %d, hw_subframe %d (time %lli)\n", frame, hw_subframe, rt_get_time_ns()-T0 );
-
-      if (start_rx_stream == 1) {
-	LOG_D(PHY,"Locking mutex_rx (IC %d)\n",UE->instance_cnt_rx);
-        if (pthread_mutex_lock(&UE->mutex_rx) != 0) {
-          LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RX thread\n" );
-          exit_fun("nothing to add");
-          return &UE_thread_retval;
-        }
-
-        int instance_cnt_rx = ++UE->instance_cnt_rx;
-
-	LOG_D(PHY,"Unlocking mutex_rx (IC %d)\n",instance_cnt_rx);
-        if (pthread_mutex_unlock(&UE->mutex_rx) != 0) {
-          LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RX thread\n" );
-          exit_fun("nothing to add");
-          return &UE_thread_retval;
-        }
-
-	VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE_INST_CNT_RX, instance_cnt_rx);
-
-
-        if (instance_cnt_rx == 0) {
-	  LOG_D(HW,"signalling rx thread to wake up, hw_frame %d, hw_subframe %d (time %lli)\n", frame, hw_subframe, rt_get_time_ns()-T0 );
-          if (pthread_cond_signal(&UE->proc.cond_rx) != 0) {
-            LOG_E( PHY, "[SCHED][UE] ERROR pthread_cond_signal for UE RX thread\n" );
-            exit_fun("nothing to add");
-            return &UE_thread_retval;
-          }
-	  
-	  LOG_D(HW,"signalled rx thread to wake up, hw_frame %d, hw_subframe %d (time %lli)\n", frame, hw_subframe, rt_get_time_ns()-T0 );
-	  if (UE->mode == loop_through_memory) {
-	    printf("Processing subframe %d",UE->slot_rx>>1);
-	    getchar();
-	  }
-
-          if (UE->mode == rx_calib_ue) {
-            if (frame == 10) {
-              LOG_D(PHY,
-                    "[SCHED][UE] Found cell with N_RB_DL %"PRIu8", PHICH CONFIG (%d,%d), Nid_cell %"PRIu16", NB_ANTENNAS_TX %"PRIu8", frequency offset "PRIi32" Hz, RSSI (digital) %hu dB, measured Gain %d dB, total_rx_gain %"PRIu32" dB, USRP rx gain %f dB\n",
-                    UE->frame_parms.N_RB_DL,
-                    UE->frame_parms.phich_config_common.phich_duration,
-                    UE->frame_parms.phich_config_common.phich_resource,
-                    UE->frame_parms.Nid_cell,
-                    UE->frame_parms.nb_antennas_tx_eNB,
-                    UE->common_vars.freq_offset,
-                    UE->measurements.rx_power_avg_dB[0],
-                    UE->measurements.rx_power_avg_dB[0] - rx_input_level_dBm,
-                    UE->rx_total_gain_dB,
-                    openair0_cfg[0].rx_gain[0]
-                   );
-              exit_fun("[HW][UE] UE in RX calibration mode, exiting");
-              return &UE_thread_retval;
-            }
-          }
-        } else {
-          LOG_E( PHY, "[SCHED][UE] UE RX thread busy (IC %d)!!\n", instance_cnt_rx);
-	  if (instance_cnt_rx > 2) {
-	    exit_fun("instance_cnt_rx > 1");
-	    return &UE_thread_retval;
-	  }
-        }
-
-       
-        if ((tx_enabled==1)&&(UE->mode != loop_through_memory)) {
-
-	  if (pthread_mutex_lock(&UE->mutex_tx) != 0) {
-	    LOG_E( PHY, "[SCHED][UE] error locking mutex for UE TX thread\n" );
-	    exit_fun("nothing to add");
-	    return &UE_thread_retval;
-	  }
-
-
-          int instance_cnt_tx = ++UE->instance_cnt_tx;
-
-          if (pthread_mutex_unlock(&UE->mutex_tx) != 0) {
-            LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE TX thread\n" );
-            exit_fun("nothing to add");
-            return &UE_thread_retval;
-          }
-	  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE_INST_CNT_TX, instance_cnt_tx);
+}
 
 
-          if (instance_cnt_tx == 0) {
-            if (pthread_cond_signal(&UE->cond_tx) != 0) {
-              LOG_E( PHY, "[SCHED][UE] ERROR pthread_cond_signal for UE TX thread\n" );
-              exit_fun("nothing to add");
-              return &UE_thread_retval;
+#ifdef OPENAIR2
+void fill_ue_band_info(void) {
+
+    UE_EUTRA_Capability_t *UE_EUTRA_Capability = UE_rrc_inst[0].UECap->UE_EUTRA_Capability;
+    int i,j;
+
+    bands_to_scan.nbands = UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.count;
+
+    for (i=0; i<bands_to_scan.nbands; i++) {
+
+        for (j=0; j<sizeof (eutra_bands) / sizeof (eutra_bands[0]); j++)
+            if (eutra_bands[j].band == UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA) {
+                memcpy(&bands_to_scan.band_info[i],
+                       &eutra_bands[j],
+                       sizeof(eutra_band_t));
+
+                printf("Band %d (%lu) : DL %u..%u Hz, UL %u..%u Hz, Duplex %s \n",
+                       bands_to_scan.band_info[i].band,
+                       UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA,
+                       bands_to_scan.band_info[i].dl_min,
+                       bands_to_scan.band_info[i].dl_max,
+                       bands_to_scan.band_info[i].ul_min,
+                       bands_to_scan.band_info[i].ul_max,
+                       (bands_to_scan.band_info[i].frame_type==FDD) ? "FDD" : "TDD");
+                break;
             }
-	    LOG_D(HW,"signalled tx thread to wake up, hw_frame %d, hw_subframe %d (time %lli)\n", frame, hw_subframe, rt_get_time_ns()-T0 );
-
-          } else {
-            LOG_E( PHY, "[SCHED][UE] UE TX thread busy (IC %d)!!\n" );
-	    if (instance_cnt_tx>2) {
-	      exit_fun("instance_cnt_tx > 1");
-	      return &UE_thread_retval;
-	    }
-          }
-        }
-
-      }
-    } else {
-      // we are not yet synchronized
-      if ((hw_subframe == 9) && (dummy_dump == 0)) {
-        // Wake up initial synch thread
-        if (pthread_mutex_lock(&UE->mutex_synch) != 0) {
-          LOG_E( PHY, "[SCHED][UE] error locking mutex for UE initial synch thread\n" );
-          exit_fun("nothing to add");
-          return &UE_thread_retval;
-        }
-
-        int instance_cnt_synch = ++UE->instance_cnt_synch;
-
-        if (pthread_mutex_unlock(&UE->mutex_synch) != 0) {
-          LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE initial synch thread\n" );
-          exit_fun("nothing to add");
-          return &UE_thread_retval;
-        }
-
-        dummy_dump = 1;
-
-        if (instance_cnt_synch == 0) {
-          if (pthread_cond_signal(&UE->cond_synch) != 0) {
-            LOG_E( PHY, "[SCHED][UE] ERROR pthread_cond_signal for UE sync thread\n" );
-            exit_fun("nothing to add");
-            return &UE_thread_retval;
-          }
-        } else {
-          LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
-          exit_fun("nothing to add");
-          return &UE_thread_retval;
-        }
-      }
     }
-
-    hw_subframe++;
-    slot+=2;
-
-    if (hw_subframe==10) {
-      hw_subframe = 0;
-      first_rx = 1;
-      frame++;
-      slot = 1;
-
-      int fail = pthread_mutex_lock(&UE->mutex_synch);
-      int instance_cnt_synch = UE->instance_cnt_synch;
-      fail = fail || pthread_mutex_unlock(&UE->mutex_synch);
-
-      if (fail) {
-        LOG_E( PHY, "[SCHED][UE] error (un-)locking mutex for UE synch\n" );
-        exit_fun("noting to add");
-        return &UE_thread_retval;
-      }
-
-      if (instance_cnt_synch < 0) {
-        // the UE_thread_synch is ready
-        if (UE->is_synchronized == 1) {
-          rx_off_diff = 0;
-          LTE_DL_FRAME_PARMS *frame_parms = &UE->frame_parms; // for macro FRAME_LENGTH_COMPLEX_SAMPLES
-
-	  //	  LOG_I(PHY,"UE->rx_offset %d\n",UE->rx_offset);
-          if ((UE->rx_offset > RX_OFF_MAX) && (start_rx_stream == 0)) {
-            start_rx_stream=1;
-            frame=0;
-            // dump ahead in time to start of frame
-
-#ifndef USRP_DEBUG
-	    if (UE->mode != loop_through_memory) {
-	      LOG_I(PHY,"Resynchronizing RX by %d samples\n",UE->rx_offset);
-	      rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					   &timestamp,
-					   (void**)rxdata,
-					   UE->rx_offset,
-					   UE->frame_parms.nb_antennas_rx);
-	      if (rxs != UE->rx_offset) {
-		exit_fun("problem in rx");
-		return &UE_thread_retval;
-	      }
-	      UE->rx_offset=0;
-	      tx_enabled = 1;
-	    }
-	    else
-	      rt_sleep_ns(1000000);
-#else
-            rt_sleep_ns(10000000);
+}
 #endif
 
-          } else if ((UE->rx_offset<(FRAME_LENGTH_COMPLEX_SAMPLES/2)) &&
-		     (UE->rx_offset > RX_OFF_MIN) && 
-		     (start_rx_stream==1) && 
-		     (rx_correction_timer == 0)) {
-            rx_off_diff = -UE->rx_offset + RX_OFF_MIN;
-	    LOG_D(PHY,"UE->rx_offset %d > %d, diff %d\n",UE->rx_offset,RX_OFF_MIN,rx_off_diff);
-            rx_correction_timer = 5;
-          } else if ((UE->rx_offset>(FRAME_LENGTH_COMPLEX_SAMPLES/2)) && 
-		     (UE->rx_offset < (FRAME_LENGTH_COMPLEX_SAMPLES-RX_OFF_MIN)) &&
-		     (start_rx_stream==1) && 
-		     (rx_correction_timer == 0)) {   // moving to the left so drop rx_off_diff samples
-            rx_off_diff = FRAME_LENGTH_COMPLEX_SAMPLES - RX_OFF_MIN - UE->rx_offset;
-	    LOG_D(PHY,"UE->rx_offset %d < %d, diff %d\n",UE->rx_offset,FRAME_LENGTH_COMPLEX_SAMPLES-RX_OFF_MIN,rx_off_diff);
-
-            rx_correction_timer = 5;
-          }
-
-          if (rx_correction_timer>0)
-            rx_correction_timer--;
-        }
+int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg) {
 
-        dummy_dump=0;
-      }
-    }
+    int i, CC_id;
+    LTE_DL_FRAME_PARMS *frame_parms;
+    openair0_rf_map *rf_map;
 
-#if defined(ENABLE_ITTI)
-    itti_update_lte_time(frame, slot);
-#endif
-  }
+    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+        rf_map = &phy_vars_ue[CC_id]->rf_map;
 
-  return &UE_thread_retval;
-}
+        AssertFatal( phy_vars_ue[CC_id] !=0, "");
+        frame_parms = &(phy_vars_ue[CC_id]->frame_parms);
 
-*/
-
-/*!
- * \brief Initialize the UE theads.
- * Creates the UE threads:
- * - UE_thread_rxtx0
- * - UE_thread_rxtx1
- * - UE_thread_synch
- * and the locking between them.
- */
-void init_UE_threads(int inst)
-{
-  PHY_VARS_UE *UE;
- 
-  UE = PHY_vars_UE_g[inst][0];
-
-  pthread_attr_init (&UE->proc.attr_ue);
-  pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);
-  
-#ifndef LOWLATENCY
-  UE->proc.sched_param_ue.sched_priority = sched_get_priority_max(SCHED_FIFO);
-  pthread_attr_setschedparam(&UE->proc.attr_ue,&sched_param_UE_thread);
-#endif
-
-  // the threads are not yet active, therefore access is allowed without locking
-  UE->proc.proc_rxtx[0].instance_cnt_rxtx = -1;
-  UE->proc.proc_rxtx[1].instance_cnt_rxtx = -1;
-  UE->proc.instance_cnt_synch = -1;
-  pthread_mutex_init(&UE->proc.proc_rxtx[0].mutex_rxtx,NULL);
-  pthread_mutex_init(&UE->proc.proc_rxtx[1].mutex_rxtx,NULL);
-  pthread_mutex_init(&UE->proc.mutex_synch,NULL);
-  pthread_cond_init(&UE->proc.proc_rxtx[0].cond_rxtx,NULL);
-  pthread_cond_init(&UE->proc.proc_rxtx[1].cond_rxtx,NULL);
-  pthread_cond_init(&UE->proc.cond_synch,NULL);
-  pthread_create(&UE->proc.proc_rxtx[0].pthread_rxtx,NULL,UE_thread_rxn_txnp4,(void*)&UE->proc.proc_rxtx[0]);
-  pthread_setname_np( UE->proc.proc_rxtx[0].pthread_rxtx, "UE_thread_rxn_txnp4_even" );
-  pthread_create(&UE->proc.proc_rxtx[1].pthread_rxtx,NULL,UE_thread_rxn_txnp4,(void*)&UE->proc.proc_rxtx[1]);
-  pthread_setname_np( UE->proc.proc_rxtx[1].pthread_rxtx, "UE_thread_rxn_txnp4_odd" );
-  pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void*)UE);
-  pthread_setname_np( UE->proc.pthread_synch, "UE_thread_synch" );
-}
+        // replace RX signal buffers with mmaped HW versions
+        rxdata = (int32_t**)malloc16( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
+        txdata = (int32_t**)malloc16( frame_parms->nb_antennas_tx*sizeof(int32_t*) );
 
+        for (i=0; i<frame_parms->nb_antennas_rx; i++) {
+            LOG_I(PHY, "Mapping UE CC_id %d, rx_ant %d, freq %u on card %d, chain %d\n",
+                  CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
+            free( phy_vars_ue[CC_id]->common_vars.rxdata[i] );
+            rxdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
+            phy_vars_ue[CC_id]->common_vars.rxdata[i] = rxdata[i]; // what about the "-N_TA_offset" ? // N_TA offset for TDD
+        }
 
-#ifdef OPENAIR2
-void fill_ue_band_info(void)
-{
-
-  UE_EUTRA_Capability_t *UE_EUTRA_Capability = UE_rrc_inst[0].UECap->UE_EUTRA_Capability;
-  int i,j;
-
-  bands_to_scan.nbands = UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.count;
-
-  for (i=0; i<bands_to_scan.nbands; i++) {
-
-    for (j=0; j<sizeof (eutra_bands) / sizeof (eutra_bands[0]); j++)
-      if (eutra_bands[j].band == UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA) {
-        memcpy(&bands_to_scan.band_info[i],
-               &eutra_bands[j],
-               sizeof(eutra_band_t));
-
-        printf("Band %d (%lu) : DL %u..%u Hz, UL %u..%u Hz, Duplex %s \n",
-               bands_to_scan.band_info[i].band,
-               UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA,
-               bands_to_scan.band_info[i].dl_min,
-               bands_to_scan.band_info[i].dl_max,
-               bands_to_scan.band_info[i].ul_min,
-               bands_to_scan.band_info[i].ul_max,
-               (bands_to_scan.band_info[i].frame_type==FDD) ? "FDD" : "TDD");
-        break;
-      }
-  }
-}
-#endif
+        for (i=0; i<frame_parms->nb_antennas_tx; i++) {
+            LOG_I(PHY, "Mapping UE CC_id %d, tx_ant %d, freq %u on card %d, chain %d\n",
+                  CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
+            free( phy_vars_ue[CC_id]->common_vars.txdata[i] );
+            txdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
+            phy_vars_ue[CC_id]->common_vars.txdata[i] = txdata[i];
+        }
 
-int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg)
-{
-
-  int i, CC_id;
-  LTE_DL_FRAME_PARMS *frame_parms;
-  openair0_rf_map *rf_map;
-
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-    rf_map = &phy_vars_ue[CC_id]->rf_map;
-    
-    if (phy_vars_ue[CC_id]) {
-      frame_parms = &(phy_vars_ue[CC_id]->frame_parms);
-    } else {
-      printf("phy_vars_UE[%d] not initialized\n", CC_id);
-      return(-1);
-    }
-    
-    /*
-    if (frame_parms->frame_type == TDD) {
-      if (frame_parms->N_RB_DL == 100)
-        N_TA_offset = 624;
-      else if (frame_parms->N_RB_DL == 50)
-        N_TA_offset = 624/2;
-      else if (frame_parms->N_RB_DL == 25)
-        N_TA_offset = 624/4;
-      }
-    */
-    
-    // replace RX signal buffers with mmaped HW versions
-    rxdata = (int32_t**)malloc16( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
-    txdata = (int32_t**)malloc16( frame_parms->nb_antennas_tx*sizeof(int32_t*) );
-    
-    for (i=0; i<frame_parms->nb_antennas_rx; i++) {
-      printf( "Mapping UE CC_id %d, rx_ant %d, freq %u on card %d, chain %d\n", CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
-      free( phy_vars_ue[CC_id]->common_vars.rxdata[i] );
-      rxdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
-      phy_vars_ue[CC_id]->common_vars.rxdata[i] = rxdata[i]; // what about the "-N_TA_offset" ? // N_TA offset for TDD
-      printf("rxdata[%d] : %p\n",i,rxdata[i]);
-    }
-    
-    for (i=0; i<frame_parms->nb_antennas_tx; i++) {
-      printf( "Mapping UE CC_id %d, tx_ant %d, freq %u on card %d, chain %d\n", CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
-      free( phy_vars_ue[CC_id]->common_vars.txdata[i] );
-      txdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
-      phy_vars_ue[CC_id]->common_vars.txdata[i] = txdata[i];
-      printf("txdata[%d] : %p\n",i,txdata[i]);
+        // rxdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.rxdata[x]
+        // txdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.txdata[x]
+        // be careful when releasing memory!
+        // because no "release_ue_buffers"-function is available, at least rxdata and txdata memory will leak (only some bytes)
     }
-    
-    // rxdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.rxdata[x]
-    // txdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.txdata[x]
-    // be careful when releasing memory!
-    // because no "release_ue_buffers"-function is available, at least rxdata and txdata memory will leak (only some bytes)
-    
-  }
-
-  return 0;
+    return 0;
 }
-- 
2.26.2