Restore original UE_phy_stub_single_thread_rxn_txnp4

Rename our version to `UE_phy_stub_standalone_pnf_task`

targets/RT/USER/lte-ue.c

@@ -970,7 +970,10 @@ void ue_stub_rx_handler(unsigned int num_bytes,
   }
 }
 
-static uint64_t clock_usec() {
+static uint64_t clock_usec(void);
+
+static uint64_t clock_usec()
+{
   struct timespec t;
   if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) {
     abort();
@@ -986,12 +989,12 @@ static uint64_t clock_usec() {
  * \returns a pointer to an int. The storage is not on the heap and must not be freed.
  */
 
-static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
+static void *UE_phy_stub_standalone_pnf_task(void *arg)
+{
   thread_top_init("UE_phy_stub_thread_rxn_txnp4", 1, 870000L, 1000000L, 1000000L);
   // for multipule UE's L2-emulator
   //module_id_t Mod_id = 0;
   //int init_ra_UE = -1; // This counter is used to initiate the RA of each UE in different SFrames
-  static __thread int UE_thread_rxtx_retval;
   struct rx_tx_thread_data *rtd = arg;
 
   if (rtd == NULL) {
@@ -1031,7 +1034,7 @@ static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
   sync_var = 0;
 
   //PANOS: CAREFUL HERE!
-  wait_sync("UE_phy_stub_single_thread_rxn_txnp4");
+  wait_sync("UE_phy_stub_standalone_pnf_task");
 
   int num_pairs = 0;
   int num_lone = 0;
@@ -1144,7 +1147,7 @@ static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
     for (ue_index = 0; ue_index < ue_num; ue_index++) {
       ue_Mod_id = ue_thread_id + NB_THREAD_INST * ue_index;
       UE = PHY_vars_UE_g[ue_Mod_id][0];
-      //LOG_D(MAC, "UE_phy_stub_single_thread_rxn_txnp4, NB_UE_INST:%d, Mod_id:%d \n", NB_UE_INST, Mod_id);
+      //LOG_D(MAC, "UE_phy_stub_standalone_pnf_task, NB_UE_INST:%d, Mod_id:%d \n", NB_UE_INST, Mod_id);
       //UE = PHY_vars_UE_g[Mod_id][0];
       lte_subframe_t sf_type = subframe_select(&UE->frame_parms, proc->subframe_rx);
 
@@ -1347,9 +1350,432 @@ static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
 
   // thread finished
   free(arg);
-  return &UE_thread_rxtx_retval;
+  return NULL;
+}
+
+/*!
+ * \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.
+ */
+
+static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg)
+{
+#if 0 // TODO: doesn't currently compile
+  thread_top_init("UE_phy_stub_thread_rxn_txnp4",1,870000L,1000000L,1000000L);
+  // for multipule UE's L2-emulator
+  //module_id_t Mod_id = 0;
+  //int init_ra_UE = -1; // This counter is used to initiate the RA of each UE in different SFrames
+  static __thread int UE_thread_rxtx_retval;
+  struct rx_tx_thread_data *rtd = arg;
+
+  if (rtd == NULL) {
+    LOG_E( MAC, "[SCHED][UE] rx_tx_thread_data *rtd: NULL pointer\n" );
+    exit_fun("nothing to add");
+  }
+
+  UE_rxtx_proc_t *proc = rtd->proc;
+  // settings for nfapi-L2-emulator mode
+  module_id_t ue_thread_id = rtd->ue_thread_id;
+  uint16_t     ue_index = 0;
+  uint16_t     ue_num = NB_UE_INST/NB_THREAD_INST+((NB_UE_INST%NB_THREAD_INST > ue_thread_id) ? 1 :0);
+  module_id_t ue_Mod_id;
+  PHY_VARS_UE    *UE = NULL;
+  int ret;
+  uint8_t   end_flag;
+  proc = &PHY_vars_UE_g[0][0]->proc.proc_rxtx[0];
+  phy_stub_ticking->num_single_thread[ue_thread_id] = -1;
+  UE = rtd->UE;
+
+  UL_INFO = (UL_IND_t *)malloc(sizeof(UL_IND_t));
+  UL_INFO->rx_ind.rx_indication_body.rx_pdu_list = calloc(NB_UE_INST, sizeof(nfapi_rx_indication_pdu_t));
+  UL_INFO->rx_ind.rx_indication_body.number_of_pdus = 0;
+  UL_INFO->crc_ind.crc_indication_body.crc_pdu_list = calloc(NB_UE_INST, sizeof(nfapi_crc_indication_pdu_t));
+  UL_INFO->crc_ind.crc_indication_body.number_of_crcs = 0;
+  UL_INFO->harq_ind.harq_indication_body.harq_pdu_list = calloc(NB_UE_INST, sizeof(nfapi_harq_indication_pdu_t));
+  UL_INFO->harq_ind.harq_indication_body.number_of_harqs = 0;
+  UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = calloc(NB_UE_INST, sizeof(nfapi_sr_indication_pdu_t));
+  UL_INFO->sr_ind.sr_indication_body.number_of_srs = 0;
+  UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list =  calloc(NB_UE_INST, sizeof(nfapi_cqi_indication_pdu_t));
+  UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list = calloc(NB_UE_INST, sizeof(nfapi_cqi_indication_raw_pdu_t));
+  UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis = 0;
+
+  if(ue_thread_id == 0) {
+    phy_stub_ticking->ticking_var = -1;
+    proc->subframe_rx=proc->sub_frame_start;
+    // Initializations for nfapi-L2-emulator mode
+    dl_config_req = NULL;
+    ul_config_req = NULL;
+    hi_dci0_req        = NULL;
+    tx_request_pdu_list = NULL;
+
+    // waiting for all UE's threads set phy_stub_ticking->num_single_thread[ue_thread_id] = -1.
+    do {
+      end_flag = 1;
+
+      for(uint16_t i = 0; i< NB_THREAD_INST; i++) {
+        if(phy_stub_ticking->num_single_thread[i] == 0) {
+          end_flag = 0;
+        }
+      }
+    } while(end_flag == 0);
+
+    sync_var=0;
+  }
+
+  //PANOS: CAREFUL HERE!
+  wait_sync("UE_phy_stub_single_thread_rxn_txnp4");
+
+  while (!oai_exit) {
+    if(ue_thread_id == 0) {
+      if (pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error locking mutex for UE RXTX\n" );
+        exit_fun("nothing to add");
+      }
+
+      while (phy_stub_ticking->ticking_var < 0) {
+        // most of the time, the thread is waiting here
+        //pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx )
+        LOG_D(MAC,"Waiting for ticking_var\n");
+        pthread_cond_wait( &phy_stub_ticking->cond_ticking, &phy_stub_ticking->mutex_ticking);
+      }
+
+      phy_stub_ticking->ticking_var--;
+
+      if (pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
+        exit_fun("nothing to add");
+      }
+
+      proc->subframe_rx=timer_subframe;
+      proc->frame_rx = timer_frame;
+      // FDD and TDD tx timing settings.
+      // XXX:It is the result of timing adjustment in debug.
+      // It is necessary to investigate why this will work in the future.
+      proc->subframe_tx=(timer_subframe+sf_ahead)%10;
+      proc->frame_tx = proc->frame_rx + (proc->subframe_rx>(9-sf_ahead)?1:0);
+      //oai_subframe_ind(proc->frame_rx, proc->subframe_rx);
+
+      if (UE != NULL) {
+        if (UE->frame_parms.frame_type == FDD) {
+          oai_subframe_ind(proc->frame_rx, proc->subframe_rx);
+        } else {
+          oai_subframe_ind(proc->frame_tx, proc->subframe_tx);
+        }
+      } else {
+        // Default will be FDD
+        oai_subframe_ind(proc->frame_rx, proc->subframe_rx);
+      }
+
+      //Guessing that the next 4 lines are not needed for the phy_stub mode.
+      /*initRefTimes(t2);
+        initRefTimes(t3);
+        pickTime(current);
+        updateTimes(proc->gotIQs, &t2, 10000, "Delay to wake up UE_Thread_Rx (case 2)");*/
+
+      if (pthread_mutex_lock(&phy_stub_ticking->mutex_single_thread) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error locking mutex for ue_thread_id %d (mutex_single_thread)\n",ue_thread_id);
+        exit_fun("nothing to add");
+      }
+
+      memset(&phy_stub_ticking->num_single_thread[0],0,sizeof(int)*NB_THREAD_INST);
+      pthread_cond_broadcast(&phy_stub_ticking->cond_single_thread);
+
+      if (pthread_mutex_unlock(&phy_stub_ticking->mutex_single_thread) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error unlocking mutex for ue_thread_id %d (mutex_single_thread)\n",ue_thread_id);
+        exit_fun("nothing to add");
+      }
+    } else {
+      if (pthread_mutex_lock(&phy_stub_ticking->mutex_single_thread) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error locking mutex for ue_thread_id %d (mutex_single_thread)\n",ue_thread_id);
+        exit_fun("nothing to add");
+      }
+
+      while (phy_stub_ticking->num_single_thread[ue_thread_id] < 0) {
+        // most of the time, the thread is waiting here
+        LOG_D(MAC,"Waiting for single_thread (ue_thread_id %d)\n",ue_thread_id);
+        pthread_cond_wait( &phy_stub_ticking->cond_single_thread, &phy_stub_ticking->mutex_single_thread);
+      }
+
+      if (pthread_mutex_unlock(&phy_stub_ticking->mutex_single_thread) != 0) {
+        LOG_E( MAC, "[SCHED][UE] error unlocking mutex for ue_thread_id %d (mutex_single_thread)\n",ue_thread_id);
+        exit_fun("nothing to add");
+      }
+    }
+
+    if (dl_config_req && tx_request_pdu_list) {
+      nfapi_dl_config_request_body_t* dl_config_req_body = &dl_config_req->dl_config_request_body;
+      for (int i = 0; i < dl_config_req_body->number_pdu; ++i) {
+        nfapi_dl_config_request_pdu_t* pdu = &dl_config_req_body->dl_config_pdu_list[i];
+        if (pdu->pdu_type ==  NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) {
+          i += 1;
+          AssertFatal(i < dl_config_req->dl_config_request_body.number_pdu,
+                      "Need PDU following DCI at index %d, but not found\n",
+                      i);
+          nfapi_dl_config_request_pdu_t *dlsch = &dl_config_req_body->dl_config_pdu_list[i];
+          if (dlsch->pdu_type != NFAPI_DL_CONFIG_DLSCH_PDU_TYPE) {
+            LOG_E(MAC, "expected DLSCH PDU at index %d\n", i);
+            continue;
+          }
+          dl_config_req_UE_MAC_dci(NFAPI_SFNSF2SFN(dl_config_req->sfn_sf),
+                                   NFAPI_SFNSF2SF(dl_config_req->sfn_sf),
+                                   pdu,
+                                   dlsch,
+                                   ue_num);
+        } else if (pdu->pdu_type == NFAPI_DL_CONFIG_BCH_PDU_TYPE) {
+          dl_config_req_UE_MAC_bch(NFAPI_SFNSF2SFN(dl_config_req->sfn_sf),
+                                   NFAPI_SFNSF2SF(dl_config_req->sfn_sf),
+                                   pdu,
+                                   ue_num);
+        } else if (pdu->pdu_type == NFAPI_DL_CONFIG_MCH_PDU_TYPE) {
+          dl_config_req_UE_MAC_mch(NFAPI_SFNSF2SFN(dl_config_req->sfn_sf),
+                                   NFAPI_SFNSF2SF(dl_config_req->sfn_sf),
+                                   pdu,
+                                   ue_num);
+        }
+      }
+    }
+
+    if (hi_dci0_req) {
+      nfapi_hi_dci0_request_body_t *hi_dci0_body = &hi_dci0_req->hi_dci0_request_body;
+      for (int i = 0; i < hi_dci0_body->number_of_dci + hi_dci0_body->number_of_hi; i++) {
+        nfapi_hi_dci0_request_pdu_t* pdu = &hi_dci0_body->hi_dci0_pdu_list[i];
+        hi_dci0_req_UE_MAC(NFAPI_SFNSF2SFN(hi_dci0_req->sfn_sf),
+                           NFAPI_SFNSF2SF(hi_dci0_req->sfn_sf),
+                           pdu,
+                           ue_num);
+      }
+    }
+
+    //for (Mod_id=0; Mod_id<NB_UE_INST; Mod_id++) {
+    for (ue_index=0; ue_index < ue_num; ue_index++) {
+      ue_Mod_id = ue_thread_id + NB_THREAD_INST*ue_index;
+      UE = PHY_vars_UE_g[ue_Mod_id][0];
+      //LOG_D(MAC, "UE_phy_stub_single_thread_rxn_txnp4, NB_UE_INST:%d, Mod_id:%d \n", NB_UE_INST, Mod_id);
+      //UE = PHY_vars_UE_g[Mod_id][0];
+      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, "TDD%d,%s: calling UE_RX\n",
+                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: calling UE_RX\n",
+                (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_SL_RX(UE,proc);
+
+        if(NFAPI_MODE!=NFAPI_UE_STUB_PNF)
+          phy_procedures_UE_SL_TX(UE,proc);
+      }
+
+#if UE_TIMING_TRACE
+      start_meas(&UE->generic_stat);
+#endif
+
+      if (UE->mac_enabled==1) {
+        ret = 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) {
+          LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u %s\n",
+                 UE->Mod_id, proc->frame_rx, proc->subframe_tx,get_connectionloss_errstr(ret) );
+        }
+      }
+
+#if UE_TIMING_TRACE
+      stop_meas(&UE->generic_stat);
+#endif
+
+      // Prepare the future Tx data
+
+      if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
+          (UE->frame_parms.frame_type == FDD) )
+        if (UE->mode != loop_through_memory) {
+          // We make the start of RA between consecutive UEs differ by 20 frames
+          //if ((UE_mac_inst[Mod_id].UE_mode[0] == PRACH  && Mod_id == 0) || (UE_mac_inst[Mod_id].UE_mode[0] == PRACH && Mod_id>0 && proc->frame_rx >= UE_mac_inst[Mod_id-1].ra_frame + 20) ) {
+          if (UE_mac_inst[ue_Mod_id].UE_mode[0] == PRACH  && ue_Mod_id == next_Mod_id) {
+            next_ra_frame++;
+
+            if(next_ra_frame > 500) {
+              // check if we have PRACH opportunity
+              if (is_prach_subframe(&UE->frame_parms,proc->frame_tx, proc->subframe_tx) &&  UE_mac_inst[ue_Mod_id].SI_Decoded == 1) {
+                // The one working strangely...
+                //if (is_prach_subframe(&UE->frame_parms,proc->frame_tx, proc->subframe_tx && Mod_id == (module_id_t) init_ra_UE) ) {
+                PRACH_RESOURCES_t *prach_resources = ue_get_rach(ue_Mod_id, 0, proc->frame_tx, 0, proc->subframe_tx);
+
+                if(prach_resources!=NULL ) {
+                  UE_mac_inst[ue_Mod_id].ra_frame = proc->frame_rx;
+                  LOG_D(MAC, "UE_phy_stub_thread_rxn_txnp4 before RACH, Mod_id: %d frame %d subframe %d\n", ue_Mod_id,proc->frame_tx, proc->subframe_tx);
+                  fill_rach_indication_UE_MAC(ue_Mod_id, proc->frame_tx,proc->subframe_tx, UL_INFO, prach_resources->ra_PreambleIndex, prach_resources->ra_RNTI);
+                  Msg1_transmitted(ue_Mod_id, 0, proc->frame_tx, 0);
+                  UE_mac_inst[ue_Mod_id].UE_mode[0] = RA_RESPONSE;
+                  next_Mod_id = ue_Mod_id + 1;
+                  //next_ra_frame = (proc->frame_rx + 20)%1000;
+                  next_ra_frame = 0;
+                }
+
+                //ue_prach_procedures(ue,proc,eNB_id,abstraction_flag,mode);
+              }
+            }
+          } // mode is PRACH
+
+          // Substitute call to phy_procedures Tx with call to phy_stub functions in order to trigger
+          // UE Tx procedures directly at the MAC layer, based on the received ul_config requests from the vnf (eNB).
+          // Generate UL_indications which correspond to UL traffic.
+          if(ul_config_req!=NULL) { //&& UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL){
+            ul_config_req_UE_MAC(ul_config_req, timer_frame, timer_subframe, ue_Mod_id);
+          }
+        }
+
+      phy_procedures_UE_SL_RX(UE,proc);
+    } //for (Mod_id=0; Mod_id<NB_UE_INST; Mod_id++)
+
+    phy_stub_ticking->num_single_thread[ue_thread_id] = -1;
+
+    // waiting for all UE's threads set phy_stub_ticking->num_single_thread[ue_thread_id] = -1.
+    if(ue_thread_id == 0) {
+      do {
+        end_flag = 1;
+
+        for(uint16_t i = 0; i< NB_THREAD_INST; i++) {
+          if(phy_stub_ticking->num_single_thread[i] == 0) {
+            end_flag = 0;
+          }
+        }
+      } while(end_flag == 0);
+
+      if (UL_INFO->crc_ind.crc_indication_body.number_of_crcs>0) {
+        //LOG_D(PHY,"UL_info->crc_ind.crc_indication_body.number_of_crcs:%d CRC_IND:SFN/SF:%d\n", UL_info->crc_ind.crc_indication_body.number_of_crcs, NFAPI_SFNSF2DEC(UL_info->crc_ind.sfn_sf));
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.2, SFN/SF of PNF counter:%d.%d, number_of_crcs: %d \n", timer_frame, timer_subframe, UL_INFO->crc_ind.crc_indication_body.number_of_crcs);
+        oai_nfapi_crc_indication(&UL_INFO->crc_ind);
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.21 \n");
+        UL_INFO->crc_ind.crc_indication_body.number_of_crcs = 0;
+      }
+
+      if (UL_INFO->rx_ind.rx_indication_body.number_of_pdus>0) {
+        //LOG_D(PHY,"UL_info->rx_ind.number_of_pdus:%d RX_IND:SFN/SF:%d\n", UL_info->rx_ind.rx_indication_body.number_of_pdus, NFAPI_SFNSF2DEC(UL_info->rx_ind.sfn_sf));
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.3, SFN/SF of PNF counter:%d.%d, number_of_pdus: %d \n", timer_frame, timer_subframe, UL_INFO->rx_ind.rx_indication_body.number_of_pdus);
+        oai_nfapi_rx_ind(&UL_INFO->rx_ind);
+
+        for(uint8_t num_pdu = 0; num_pdu < UL_INFO->rx_ind.rx_indication_body.number_of_pdus; num_pdu++) {
+          free(UL_INFO->rx_ind.rx_indication_body.rx_pdu_list[num_pdu].data);
+        }
+
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.31 \n");
+        UL_INFO->rx_ind.rx_indication_body.number_of_pdus = 0;
+      }
+
+      if (UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis > 0) {
+        oai_nfapi_cqi_indication(&UL_INFO->cqi_ind);
+        UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis = 0;
+      }
+
+      if(UL_INFO->harq_ind.harq_indication_body.number_of_harqs>0) {
+        //LOG_D(MAC, "ul_config_req_UE_MAC 2.4, SFN/SF of PNF counter:%d.%d, number_of_harqs: %d \n", timer_frame, timer_subframe, UL_INFO->harq_ind.harq_indication_body.number_of_harqs);
+        oai_nfapi_harq_indication(&UL_INFO->harq_ind);
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.41 \n");
+        UL_INFO->harq_ind.harq_indication_body.number_of_harqs =0;
+      }
+
+      if(UL_INFO->sr_ind.sr_indication_body.number_of_srs>0) {
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.5, SFN/SF of PNF counter:%d.%d, number_of_srs: %d \n", timer_frame, timer_subframe, UL_INFO->sr_ind.sr_indication_body.number_of_srs);
+        oai_nfapi_sr_indication(&UL_INFO->sr_ind);
+        //LOG_I(MAC, "ul_config_req_UE_MAC 2.51 \n");
+        UL_INFO->sr_ind.sr_indication_body.number_of_srs = 0;
+      }
+
+      // De-allocate memory of nfapi requests copies before next subframe round
+      if(dl_config_req!=NULL) {
+        if(dl_config_req->vendor_extension!=NULL) {
+          free(dl_config_req->vendor_extension);
+          dl_config_req->vendor_extension = NULL;
+        }
+
+        if(dl_config_req->dl_config_request_body.dl_config_pdu_list!=NULL) {
+          free(dl_config_req->dl_config_request_body.dl_config_pdu_list);
+          dl_config_req->dl_config_request_body.dl_config_pdu_list = NULL;
+        }
+
+        free(dl_config_req);
+        dl_config_req = NULL;
+      }
+
+      if(tx_request_pdu_list!=NULL) {
+        for (int i = 0; i < tx_req_num_elems; i++) {
+          for (int j = 0; j < tx_request_pdu_list[i].num_segments; j++) {
+            free(tx_request_pdu_list[i].segments[j].segment_data);
+            tx_request_pdu_list[i].segments[j].segment_data = NULL;
+          }
+        }
+        tx_req_num_elems = 0;
+        free(tx_request_pdu_list);
+        tx_request_pdu_list = NULL;
+      }
+
+      if(ul_config_req!=NULL) {
+        if(ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL) {
+          free(ul_config_req->ul_config_request_body.ul_config_pdu_list);
+          ul_config_req->ul_config_request_body.ul_config_pdu_list = NULL;
+        }
+
+        free(ul_config_req);
+        ul_config_req = NULL;
+      }
+
+      if(hi_dci0_req!=NULL) {
+        if(hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list!=NULL) {
+          free(hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list);
+          hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list = NULL;
+        }
+
+        free(hi_dci0_req);
+        hi_dci0_req = NULL;
+      }
+    }
+  }
+
+  // Free UL_INFO messages
+  free(UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list);
+  UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list = NULL;
+  free(UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list);
+  UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list = NULL;
+  free(UL_INFO->sr_ind.sr_indication_body.sr_pdu_list);
+  UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = NULL;
+  free(UL_INFO->harq_ind.harq_indication_body.harq_pdu_list);
+  UL_INFO->harq_ind.harq_indication_body.harq_pdu_list = NULL;
+  free(UL_INFO->crc_ind.crc_indication_body.crc_pdu_list);
+  UL_INFO->crc_ind.crc_indication_body.crc_pdu_list = NULL;
+  free(UL_INFO->rx_ind.rx_indication_body.rx_pdu_list);
+  UL_INFO->rx_ind.rx_indication_body.rx_pdu_list = NULL;
+  free(UL_INFO);
+  UL_INFO = NULL;
+#endif // disabled UE_phy_stub_single_thread_rxn_txnp4
+
+  // thread finished
+  free(arg);
+  return NULL;
 }
 
+
 /*!
  * \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.
@@ -1960,6 +2386,13 @@ void init_UE_single_thread_stub(int nb_inst)
   //int nb_threads=RX_NB_TH;
   int nb_threads=1;
 
+  void* (*task_func)(void*);
+  if (NFAPI_MODE == NFAPI_MODE_STANDALONE_PNF) {
+    task_func = UE_phy_stub_standalone_pnf_task;
+  } else {
+    task_func = UE_phy_stub_single_thread_rxn_txnp4;
+  }
+
   for(uint16_t ue_thread_id = 0; ue_thread_id < NB_THREAD_INST; ue_thread_id++) {
     UE = PHY_vars_UE_g[ue_thread_id][0];
 
@@ -1976,7 +2409,7 @@ void init_UE_single_thread_stub(int nb_inst)
       UE->proc.proc_rxtx[i].sub_frame_start=i;
       UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
       printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,nb_threads, i);
-      pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, UE_phy_stub_single_thread_rxn_txnp4, rtd);
+      pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, task_func, rtd);
     }
   }