From 0dfdf66f8a97d4efadc2489cebc23f0dc1b8bf75 Mon Sep 17 00:00:00 2001 From: magounak Date: Mon, 10 Dec 2018 14:26:44 +0100 Subject: [PATCH 1/3] vcd changes for RU_mask_tx --- common/utils/LOG/vcd_signal_dumper.c | 2 ++ common/utils/LOG/vcd_signal_dumper.h | 2 ++ common/utils/T/T_defs.h | 2 +- common/utils/T/T_messages.txt | 10 ++++++++++ targets/RT/USER/lte-enb.c | 5 +---- targets/RT/USER/lte-ru.c | 25 +++++++++++++++---------- targets/RT/USER/ru_control.c | 2 +- 7 files changed, 32 insertions(+), 16 deletions(-) diff --git a/common/utils/LOG/vcd_signal_dumper.c b/common/utils/LOG/vcd_signal_dumper.c index 12b0627a23..ac4ede9cdc 100644 --- a/common/utils/LOG/vcd_signal_dumper.c +++ b/common/utils/LOG/vcd_signal_dumper.c @@ -105,6 +105,8 @@ const char* eurecomVariablesNames[] = { "ic_enb", "l1_proc_ic", "l1_proc_tx_ic", + "mask_tx_ru", + "mask_tx_ru1", "runtime_TX_eNB", "runtime_RX_eNB", "frame_number_TX0_UE", diff --git a/common/utils/LOG/vcd_signal_dumper.h b/common/utils/LOG/vcd_signal_dumper.h index 707905ce4d..5525953688 100644 --- a/common/utils/LOG/vcd_signal_dumper.h +++ b/common/utils/LOG/vcd_signal_dumper.h @@ -82,6 +82,8 @@ typedef enum { VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB, VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC, VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC, + VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU, + VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU1, VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_TX_ENB, VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_RX_ENB, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_UE, diff --git a/common/utils/T/T_defs.h b/common/utils/T/T_defs.h index 005a7e67a1..0024e707fa 100644 --- a/common/utils/T/T_defs.h +++ b/common/utils/T/T_defs.h @@ -44,7 +44,7 @@ typedef struct { #define VCD_NUM_FUNCTIONS (218) /* number of VCD variables (to be kept up to date! see in T_messages.txt) */ -#define VCD_NUM_VARIABLES (155) +#define VCD_NUM_VARIABLES (157) /* first VCD function (to be kept up to date! see in T_messages.txt) */ #define VCD_FIRST_FUNCTION ((uintptr_t)T_VCD_FUNCTION_RT_SLEEP) diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt index c4af298ab5..a7c525c8ae 100644 --- a/common/utils/T/T_messages.txt +++ b/common/utils/T/T_messages.txt @@ -1166,6 +1166,16 @@ ID = VCD_VARIABLE_L1_PROC_TX_IC GROUP = ALL:VCD:ENB:VCD_VARIABLE FORMAT = ulong,value VCD_NAME = l1_proc_tx_ic +ID = VCD_VARIABLE_MASK_TX_RU + DESC = VCD variable MASK_TX_RU + GROUP = ALL:VCD:ENB:VCD_VARIABLE + FORMAT = ulong,value + VCD_NAME = mask_tx_ru +ID = VCD_VARIABLE_MASK_TX_RU1 + DESC = VCD variable MASK_TX_RU1 + GROUP = ALL:VCD:ENB:VCD_VARIABLE + FORMAT = ulong,value + VCD_NAME = mask_tx_ru1 ID = VCD_VARIABLE_RUNTIME_TX_ENB DESC = VCD variable RUNTIME_TX_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c index 17c497372c..780680922f 100644 --- a/targets/RT/USER/lte-enb.c +++ b/targets/RT/USER/lte-enb.c @@ -425,9 +425,6 @@ static void* L1_thread( void* param ) { VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_ENB,proc->subframe_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB,proc->frame_tx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB,proc->frame_rx); - - - if (oai_exit) break; @@ -630,7 +627,7 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) { L1_proc->frame_tx = (L1_proc->subframe_rx > (9-sf_ahead)) ? (L1_proc->frame_rx+1)&1023 : L1_proc->frame_rx; L1_proc->subframe_tx = (L1_proc->subframe_rx + sf_ahead)%10; - LOG_D(PHY,"wakeup_rxtx: L1_proc->subframe_rx %d, L1_proc->subframe_tx %d\n",L1_proc->subframe_rx,L1_proc->subframe_tx); + //printf("wakeup_rxtx: L1_proc->subframe_rx %d, L1_proc->subframe_tx %d, RU %d\n",L1_proc->subframe_rx,L1_proc->subframe_tx,ru->idx); // the thread can now be woken up if (pthread_cond_signal(&L1_proc->cond) != 0) { diff --git a/targets/RT/USER/lte-ru.c b/targets/RT/USER/lte-ru.c index ac53efbb80..a1cdd26f23 100644 --- a/targets/RT/USER/lte-ru.c +++ b/targets/RT/USER/lte-ru.c @@ -158,7 +158,7 @@ static inline void fh_if4p5_south_out(RU_t *ru) { if (subframe_select(&ru->frame_parms,ru->proc.subframe_tx)!=SF_UL) { send_IF4p5(ru,ru->proc.frame_tx, ru->proc.subframe_tx, IF4p5_PDLFFT); ru->south_out_cnt++; - LOG_I(PHY,"south_out_cnt %d, frame %d, subframe %d, RU %d\n",ru->south_out_cnt,ru->proc.frame_tx,ru->proc.subframe_tx,ru->idx); + printf("south_out_cnt %d, frame %d, subframe %d, RU %d\n",ru->south_out_cnt,ru->proc.frame_tx,ru->proc.subframe_tx,ru->idx); } /*if (ru == RC.ru[0] || ru == RC.ru[1]) { VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU+ru->idx, ru->proc.frame_tx ); @@ -1143,7 +1143,7 @@ void wakeup_L1s(RU_t *ru) { RU_proc_t *ruproc = &ru->proc; struct timespec t; - LOG_D(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top); + LOG_I(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top); // call eNB function directly @@ -1151,7 +1151,7 @@ void wakeup_L1s(RU_t *ru) { sprintf(string,"Incoming RU %d",ru->idx); AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),""); - LOG_D(PHY,"wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", + printf("wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); @@ -1501,7 +1501,8 @@ static void* ru_thread_tx( void* param ) { //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); //wait_sync("ru_thread_tx"); wait_on_condition(&proc->mutex_FH1,&proc->cond_FH1,&proc->instance_cnt_FH1,"ru_thread_tx"); - +/*printf("ru_thread_tx: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask_tx %x\n", + eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,ru->wait_cnt,eNB_proc->RU_mask_tx);*/ //printf( "ru_thread_tx ready\n"); while (!oai_exit) { @@ -1531,6 +1532,9 @@ static void* ru_thread_tx( void* param ) { release_thread(&proc->mutex_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx"); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs); + + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU+ru->idx,eNB_proc->RU_mask_tx); + for(int i = 0; inum_eNB; i++) { eNB = ru->eNB_list[i]; @@ -1545,22 +1549,22 @@ static void* ru_thread_tx( void* param ) { eNB->Mod_id,eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,eNB->num_RU,eNB_proc->RU_mask_tx); eNB_proc->RU_mask_tx |= (1<RU_list[j]->state == RU_SYNC){ + else if (eNB->RU_list[j]->state==RU_SYNC || (/*eNB->RU_list[i]->is_slave==1 &&*/ eNB->RU_list[j]->state==RU_RUN && eNB->RU_list[j]->wait_cnt==0)){ eNB_proc->RU_mask_tx |= (1<RU_mask_tx != (1<num_RU)-1) { // not all RUs have provided their information so return - LOG_I(PHY,"Not all RUs have provided their info (mask = %d)\n", eNB_proc->RU_mask_tx); + LOG_D(PHY,"Not all RUs have provided their info (mask = %d)\n", eNB_proc->RU_mask_tx); pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); } else { // all RUs TX are finished so send the ready signal to eNB processing - LOG_I(PHY,"All RUs TX are finished. Ready to send wakeup signal to eNB processing\n"); + LOG_D(PHY,"All RUs TX are finished. Ready to send wakeup signal to eNB processing\n"); eNB_proc->RU_mask_tx = 0; pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); pthread_mutex_lock( &L1_proc->mutex_RUs); L1_proc->instance_cnt_RUs = 0; - LOG_I(PHY,"ru_thread_tx send signal to L1_thread_tx with (mask = %d)\n", eNB_proc->RU_mask_tx); + LOG_D(PHY,"ru_thread_tx send signal to L1_thread_tx with (mask = %d)\n", eNB_proc->RU_mask_tx); // the thread can now be woken up if (pthread_cond_signal(&L1_proc->cond_RUs) != 0) { LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n"); @@ -1569,6 +1573,7 @@ static void* ru_thread_tx( void* param ) { pthread_mutex_unlock( &L1_proc->mutex_RUs ); } } + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU+ru->idx,eNB_proc->RU_mask_tx); } release_thread(&proc->mutex_FH1,&proc->instance_cnt_FH1,"ru_thread_tx"); return 0; @@ -1757,7 +1762,7 @@ if(!emulate_rf){ ru->wait_cnt--; - LOG_I(PHY,"RU thread %d, frame %d, subframe %d, wait_cnt %d \n",ru->idx, frame, subframe, ru->wait_cnt); + //printf("RU thread %d, frame %d, subframe %d, wait_cnt %d \n",ru->idx, frame, subframe, ru->wait_cnt); if (ru->if_south!=LOCAL_RF && ru->wait_cnt <=20 && subframe == 5 && frame != RC.ru[0]->proc.frame_rx && resynch_done == 0) { // Send RRU_frame adjust @@ -1770,7 +1775,7 @@ if(!emulate_rf){ AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),"Failed to send msg to RAU\n"); resynch_done=1; } - wakeup_L1s(ru); + /*if (ru->wait_cnt==0)*/ wakeup_L1s(ru); } else { diff --git a/targets/RT/USER/ru_control.c b/targets/RT/USER/ru_control.c index ca2526cbf1..5750901c51 100644 --- a/targets/RT/USER/ru_control.c +++ b/targets/RT/USER/ru_control.c @@ -705,7 +705,7 @@ void* ru_thread_control( void* param ) { if (ru->if_south == LOCAL_RF) LOG_E(PHY,"Received RRU_config_ok msg...Ignoring\n"); else{ if (ru->is_slave == 1){ - printf(PHY,"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Received RRU_sync_ok from RRU %d\n",ru->idx); + printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Received RRU_sync_ok from RRU %d\n",ru->idx); // Just change the state of the RRU to unblock ru_thread() ru->state = RU_RUN; }else LOG_E(PHY,"Received RRU_sync_ok from a master RRU...Ignoring\n"); From e170ba24fbc43e6bff64fde2759751f249344b50 Mon Sep 17 00:00:00 2001 From: magounak Date: Mon, 17 Dec 2018 15:50:23 +0100 Subject: [PATCH 2/3] RU_mask changes --- common/utils/LOG/vcd_signal_dumper.c | 3 +- common/utils/LOG/vcd_signal_dumper.h | 3 +- common/utils/T/T_defs.h | 2 +- common/utils/T/T_messages.txt | 16 +++------ targets/RT/USER/lte-enb.c | 23 +++++++----- targets/RT/USER/lte-ru.c | 52 ++++++++++++++++------------ 6 files changed, 53 insertions(+), 46 deletions(-) diff --git a/common/utils/LOG/vcd_signal_dumper.c b/common/utils/LOG/vcd_signal_dumper.c index ac4ede9cdc..063123ca0e 100644 --- a/common/utils/LOG/vcd_signal_dumper.c +++ b/common/utils/LOG/vcd_signal_dumper.c @@ -103,10 +103,9 @@ const char* eurecomVariablesNames[] = { "frame_number_wakeup_rxtx_tx_ru", "frame_number_wakeup_rxtx_tx_ru1", "ic_enb", + "ic_enb1", "l1_proc_ic", "l1_proc_tx_ic", - "mask_tx_ru", - "mask_tx_ru1", "runtime_TX_eNB", "runtime_RX_eNB", "frame_number_TX0_UE", diff --git a/common/utils/LOG/vcd_signal_dumper.h b/common/utils/LOG/vcd_signal_dumper.h index 5525953688..daa8d4c2ca 100644 --- a/common/utils/LOG/vcd_signal_dumper.h +++ b/common/utils/LOG/vcd_signal_dumper.h @@ -80,10 +80,9 @@ typedef enum { VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU1, VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB, + VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB1, VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC, VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC, - VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU, - VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU1, VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_TX_ENB, VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_RX_ENB, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_UE, diff --git a/common/utils/T/T_defs.h b/common/utils/T/T_defs.h index 0024e707fa..eaa06d4239 100644 --- a/common/utils/T/T_defs.h +++ b/common/utils/T/T_defs.h @@ -44,7 +44,7 @@ typedef struct { #define VCD_NUM_FUNCTIONS (218) /* number of VCD variables (to be kept up to date! see in T_messages.txt) */ -#define VCD_NUM_VARIABLES (157) +#define VCD_NUM_VARIABLES (156) /* first VCD function (to be kept up to date! see in T_messages.txt) */ #define VCD_FIRST_FUNCTION ((uintptr_t)T_VCD_FUNCTION_RT_SLEEP) diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt index a7c525c8ae..860a2c5ce7 100644 --- a/common/utils/T/T_messages.txt +++ b/common/utils/T/T_messages.txt @@ -950,7 +950,6 @@ ID = buf_test #to check that everything is correct you can run: make _check_vcd #variables - ID = VCD_VARIABLE_FRAME_NUMBER_TX0_ENB DESC = VCD variable FRAME_NUMBER_TX0_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE @@ -1156,6 +1155,11 @@ ID = VCD_VARIABLE_IC_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE FORMAT = ulong,value VCD_NAME = ic_enb +ID = VCD_VARIABLE_IC_ENB1 + DESC = VCD variable IC_ENB1 + GROUP = ALL:VCD:ENB:VCD_VARIABLE + FORMAT = ulong,value + VCD_NAME = ic_enb1 ID = VCD_VARIABLE_L1_PROC_IC DESC = VCD variable L1_PROC_IC GROUP = ALL:VCD:ENB:VCD_VARIABLE @@ -1166,16 +1170,6 @@ ID = VCD_VARIABLE_L1_PROC_TX_IC GROUP = ALL:VCD:ENB:VCD_VARIABLE FORMAT = ulong,value VCD_NAME = l1_proc_tx_ic -ID = VCD_VARIABLE_MASK_TX_RU - DESC = VCD variable MASK_TX_RU - GROUP = ALL:VCD:ENB:VCD_VARIABLE - FORMAT = ulong,value - VCD_NAME = mask_tx_ru -ID = VCD_VARIABLE_MASK_TX_RU1 - DESC = VCD variable MASK_TX_RU1 - GROUP = ALL:VCD:ENB:VCD_VARIABLE - FORMAT = ulong,value - VCD_NAME = mask_tx_ru1 ID = VCD_VARIABLE_RUNTIME_TX_ENB DESC = VCD variable RUNTIME_TX_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c index 780680922f..4898349d12 100644 --- a/targets/RT/USER/lte-enb.c +++ b/targets/RT/USER/lte-enb.c @@ -494,21 +494,23 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) { return(-1); } pthread_mutex_lock(&eNB->proc.mutex_RU_tx); - eNB->proc.RU_mask_tx = 0; + //eNB->proc.RU_mask_tx = 0; pthread_mutex_unlock(&eNB->proc.mutex_RU_tx); if (release_thread(&proc->mutex_RUs,&proc->instance_cnt_RUs,"wakeup_txfh")<0) return(-1); for(int ru_id=0; ru_idnum_RU; ru_id++){ ru_proc = &eNB->RU_list[ru_id]->proc; fp = &eNB->RU_list[ru_id]->frame_parms; - if ((fp->frame_type == TDD) && (subframe_select(fp,proc->subframe_tx)==SF_UL)){ + if ((fp->frame_type == TDD) && (subframe_select(fp,proc->subframe_tx)==SF_UL)|| + (eNB->RU_list[ru_id]->state == RU_SYNC)|| + (eNB->RU_list[ru_id]->wait_cnt>0)){ pthread_mutex_lock(&proc->mutex_RUs); proc->instance_cnt_RUs = 0; pthread_mutex_unlock(&proc->mutex_RUs); continue;//hacking only works when all RU_tx works on the same subframe #TODO: adding mask stuff } // skip the RUs that are not synced - if (eNB->RU_list[ru_id]->state == RU_SYNC) { LOG_D(PHY,"wakeup_txfh: eNB %d : Skipping ru %d\n",eNB->Mod_id,ru_id); continue; } + //if (eNB->RU_list[ru_id]->state == RU_SYNC /*|| eNB->RU_list[ru_id]->wait_cnt>0*/) { LOG_D(PHY,"wakeup_txfh: eNB %d : Skipping ru %d\n",eNB->Mod_id,ru_id); continue; } //if(ru_proc == NULL) {return(0);} @@ -521,14 +523,14 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) { exit_fun( "error locking mutex_eNB" ); return(-1); } - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,ru_proc->instance_cnt_eNBs); + //VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,ru_proc->instance_cnt_eNBs); ru_proc->instance_cnt_eNBs = 0; - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,ru_proc->instance_cnt_eNBs); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB+ru_id,ru_proc->instance_cnt_eNBs); ru_proc->timestamp_tx = proc->timestamp_tx; ru_proc->subframe_tx = proc->subframe_tx; ru_proc->frame_tx = proc->frame_tx; - LOG_D(PHY,"wakeup_txfh: ru_proc->subframe_tx %d\n",ru_proc->subframe_tx); + // printf("wakeup_txfh: RU %d, frame_tx %d, subframe_tx %d\n",ru_id,ru_proc->frame_tx,ru_proc->subframe_tx); // the thread can now be woken up if (pthread_cond_signal(&ru_proc->cond_eNBs) != 0) { @@ -629,6 +631,11 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) { //printf("wakeup_rxtx: L1_proc->subframe_rx %d, L1_proc->subframe_tx %d, RU %d\n",L1_proc->subframe_rx,L1_proc->subframe_tx,ru->idx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->frame_rx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->subframe_rx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->frame_tx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->subframe_tx); + // the thread can now be woken up if (pthread_cond_signal(&L1_proc->cond) != 0) { LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB RXn-TXnp4 thread\n"); @@ -637,12 +644,12 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) { } pthread_mutex_unlock( &L1_proc->mutex); - +/* VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->frame_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->subframe_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->frame_tx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->subframe_tx); - +*/ return(0); } diff --git a/targets/RT/USER/lte-ru.c b/targets/RT/USER/lte-ru.c index 671c60aac1..3513b35c5d 100644 --- a/targets/RT/USER/lte-ru.c +++ b/targets/RT/USER/lte-ru.c @@ -1160,18 +1160,20 @@ void wakeup_L1s(RU_t *ru) { RU_proc_t *ruproc = &ru->proc; struct timespec t; - LOG_I(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top); + LOG_D(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top); // call eNB function directly char string[20]; sprintf(string,"Incoming RU %d",ru->idx); - - AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),""); - printf("wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", - ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); + + AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1"); + printf("wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", + ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]); +// VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); + // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); clock_gettime(CLOCK_MONOTONIC,&ru->proc.t[ru->proc.subframe_rx]); if (proc->RU_mask[ru->proc.subframe_rx] == 0){ @@ -1181,14 +1183,18 @@ void wakeup_L1s(RU_t *ru) { LOG_D(PHY,"RU %d starting timer for frame %d subframe %d\n",ru->idx, ru->proc.frame_rx,ru->proc.subframe_rx); } for (i=0;inum_RU;i++) { + if (eNB->RU_list[i]->wait_cnt==1 && ru->proc.subframe_rx!=9) eNB->RU_list[i]->wait_cnt=0; LOG_D(PHY,"RU %d has frame %d and subframe %d, state %s\n",eNB->RU_list[i]->idx,eNB->RU_list[i]->proc.frame_rx, eNB->RU_list[i]->proc.subframe_rx, ru_states[eNB->RU_list[i]->state]); - if (ru == eNB->RU_list[i]) { + if (ru == eNB->RU_list[i] && eNB->RU_list[i]->wait_cnt == 0 /*|| eNB->RU_list[i]->is_slave==0*/) { // AssertFatal((proc->RU_mask&(1<Mod_id,ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,eNB->num_RU,proc->RU_mask); proc->RU_mask[ru->proc.subframe_rx] |= (1<RU_list[i]->state == RU_SYNC || - (eNB->RU_list[i]->is_slave==1 && eNB->RU_list[i]->wait_cnt>0)){ + (eNB->RU_list[i]->is_slave==1 && eNB->RU_list[i]->wait_cnt>0 && ru!=eNB->RU_list[i])){ proc->RU_mask[ru->proc.subframe_rx] |= (1<idx,proc->RU_mask[ru->proc.subframe_rx],i); if (ru->is_slave == 0 && ( (proc->RU_mask[ru->proc.subframe_rx]&(1<RU_list[i]->state == RU_RUN) { // This is master & the RRU has already been received if (check_sync(eNB->RU_list[i],eNB->RU_list[0],ru->proc.subframe_rx) == 0) @@ -1216,7 +1222,7 @@ void wakeup_L1s(RU_t *ru) { // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); //VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); - AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),""); + AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2"); // unlock RUs that are waiting for eNB processing to be completed LOG_D(PHY,"RU %d wakeup eNB top for subframe %d\n", ru->idx,ru->proc.subframe_rx); @@ -1242,7 +1248,7 @@ void wakeup_L1s(RU_t *ru) { } else{ // not all RUs have provided their information - AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),""); + AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3"); } // pthread_mutex_unlock(&proc->mutex_RU); // LOG_D(PHY,"wakeup eNB top for for subframe %d\n", ru->proc.subframe_rx); @@ -1518,8 +1524,6 @@ static void* ru_thread_tx( void* param ) { //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); //wait_sync("ru_thread_tx"); wait_on_condition(&proc->mutex_FH1,&proc->cond_FH1,&proc->instance_cnt_FH1,"ru_thread_tx"); -/*printf("ru_thread_tx: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask_tx %x\n", - eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,ru->wait_cnt,eNB_proc->RU_mask_tx);*/ //printf( "ru_thread_tx ready\n"); while (!oai_exit) { @@ -1545,13 +1549,11 @@ static void* ru_thread_tx( void* param ) { if (ru->fh_north_out) ru->fh_north_out(ru); } - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs); + //VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs); release_thread(&proc->mutex_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx"); - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs); - - - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU+ru->idx,eNB_proc->RU_mask_tx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB+ru->idx,proc->instance_cnt_eNBs); + for(int i = 0; inum_eNB; i++) { eNB = ru->eNB_list[i]; @@ -1560,22 +1562,27 @@ static void* ru_thread_tx( void* param ) { char *L1_proc_name = (get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)? "L1_proc_tx" : "L1_proc"; pthread_mutex_lock(&eNB_proc->mutex_RU_tx); for (int j=0;jnum_RU;j++) { - if (ru == eNB->RU_list[j]) { + //printf("RU_id %d, RU_mask_tx %d, RU %x, eNB->RU_list[%d] %x\n",ru->idx,eNB_proc->RU_mask_tx,ru,j,eNB->RU_list[j]); + if (ru == eNB->RU_list[j] && eNB->RU_list[j]->wait_cnt == 0) { if ((eNB_proc->RU_mask_tx&(1< 0) LOG_E(PHY,"eNB %d frame %d, subframe %d : previous information from RU tx %d (num_RU %d,mask %x) has not been served yet!\n", eNB->Mod_id,eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,eNB->num_RU,eNB_proc->RU_mask_tx); eNB_proc->RU_mask_tx |= (1<RU_list[j]->state==RU_SYNC || (/*eNB->RU_list[i]->is_slave==1 &&*/ eNB->RU_list[j]->state==RU_RUN && eNB->RU_list[j]->wait_cnt==0)){ - eNB_proc->RU_mask_tx |= (1<RU_list[j]->state==RU_SYNC || (eNB->RU_list[j]->is_slave==1 && eNB->RU_list[j]->wait_cnt>0 && ru != eNB->RU_list[j])){ + //else if (ru->state==RU_SYNC || (eNB->RU_list[j]->is_slave==1 && ru->state==RU_RUN && eNB->RU_list[j]->wait_cnt==0)){ + eNB_proc->RU_mask_tx |= (1<idx,eNB_proc->RU_mask_tx,L1_proc->subframe_tx); } if (eNB_proc->RU_mask_tx != (1<num_RU)-1) { // not all RUs have provided their information so return - LOG_D(PHY,"Not all RUs have provided their info (mask = %d)\n", eNB_proc->RU_mask_tx); + printf("Not all RUs have provided their info (mask = %d), RU %d, num_RUs %d\n", eNB_proc->RU_mask_tx,ru->idx,eNB->num_RU); pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); } else { // all RUs TX are finished so send the ready signal to eNB processing - LOG_D(PHY,"All RUs TX are finished. Ready to send wakeup signal to eNB processing\n"); + printf("All RUs TX are finished. Ready to send wakeup signal to eNB processing, num_RUs %d, RU %d, mask %d\n", eNB->num_RU,ru->idx,eNB_proc->RU_mask_tx); eNB_proc->RU_mask_tx = 0; pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); @@ -1590,7 +1597,8 @@ static void* ru_thread_tx( void* param ) { pthread_mutex_unlock( &L1_proc->mutex_RUs ); } } - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU+ru->idx,eNB_proc->RU_mask_tx); + //printf("ru_thread_tx: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask_tx %d\n", + // eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,ru->wait_cnt,eNB_proc->RU_mask_tx); } release_thread(&proc->mutex_FH1,&proc->instance_cnt_FH1,"ru_thread_tx"); return 0; From 1723c22558d0f9060a1419dca9e6f4f528da1f1c Mon Sep 17 00:00:00 2001 From: magounak Date: Wed, 19 Dec 2018 12:34:26 +0100 Subject: [PATCH 3/3] RU_mask final changes --- common/utils/LOG/vcd_signal_dumper.c | 4 +++ common/utils/LOG/vcd_signal_dumper.h | 4 +++ common/utils/T/T_defs.h | 4 +-- common/utils/T/T_messages.txt | 20 +++++++++++++ targets/RT/USER/lte-enb.c | 6 ++-- targets/RT/USER/lte-ru.c | 44 +++++++++++++++++++++------- 6 files changed, 66 insertions(+), 16 deletions(-) diff --git a/common/utils/LOG/vcd_signal_dumper.c b/common/utils/LOG/vcd_signal_dumper.c index 063123ca0e..db7dc71774 100644 --- a/common/utils/LOG/vcd_signal_dumper.c +++ b/common/utils/LOG/vcd_signal_dumper.c @@ -63,6 +63,8 @@ struct vcd_module_s { const char* eurecomVariablesNames[] = { "frame_number_TX0_eNB", + "mask_ru", + "mask_tx_ru", "frame_number_TX1_eNB", "frame_number_RX0_eNB", "frame_number_RX1_eNB", @@ -248,6 +250,8 @@ const char* eurecomFunctionsNames[] = { "ue_lock_mutex_rxtx_for_cnt_decrement1", "ue_lock_mutex_rxtx_for_cnt_increment0", "ue_lock_mutex_rxtx_for_cnt_increment1", + "lock_mutex_ru", + "lock_mutex_ru1", /* simulation signals */ "do_DL_sig", "do_UL_sig", diff --git a/common/utils/LOG/vcd_signal_dumper.h b/common/utils/LOG/vcd_signal_dumper.h index daa8d4c2ca..7c59cb849e 100644 --- a/common/utils/LOG/vcd_signal_dumper.h +++ b/common/utils/LOG/vcd_signal_dumper.h @@ -40,6 +40,8 @@ /* WARNING: if you edit the enums below, update also string definitions in vcd_signal_dumper.c */ typedef enum { VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB=0, + VCD_SIGNAL_DUMPER_VARIABLES_MASK_RU, + VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX1_ENB, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB, VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX1_ENB, @@ -226,6 +228,8 @@ typedef enum { VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_DECREMENT1, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT0, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT1, + VCD_SIGNAL_DUMPER_FUNCTIONS_LOCK_MUTEX_RU, + VCD_SIGNAL_DUMPER_FUNCTIONS_LOCK_MUTEX_RU1, /* SIMULATION signals */ VCD_SIGNAL_DUMPER_FUNCTIONS_SIM_DO_DL_SIGNAL, VCD_SIGNAL_DUMPER_FUNCTIONS_SIM_DO_UL_SIGNAL, diff --git a/common/utils/T/T_defs.h b/common/utils/T/T_defs.h index eaa06d4239..23ce84594d 100644 --- a/common/utils/T/T_defs.h +++ b/common/utils/T/T_defs.h @@ -41,10 +41,10 @@ typedef struct { } T_cache_t; /* number of VCD functions (to be kept up to date! see in T_messages.txt) */ -#define VCD_NUM_FUNCTIONS (218) +#define VCD_NUM_FUNCTIONS (220) /* number of VCD variables (to be kept up to date! see in T_messages.txt) */ -#define VCD_NUM_VARIABLES (156) +#define VCD_NUM_VARIABLES (158) /* first VCD function (to be kept up to date! see in T_messages.txt) */ #define VCD_FIRST_FUNCTION ((uintptr_t)T_VCD_FUNCTION_RT_SLEEP) diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt index 860a2c5ce7..b2865986b4 100644 --- a/common/utils/T/T_messages.txt +++ b/common/utils/T/T_messages.txt @@ -955,6 +955,16 @@ ID = VCD_VARIABLE_FRAME_NUMBER_TX0_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE FORMAT = ulong,value VCD_NAME = frame_number_TX0_eNB +ID = VCD_VARIABLE_MASK_RU + DESC = VCD variable MASK_RU + GROUP = ALL:VCD:ENB:VCD_VARIABLE + FORMAT = ulong,value + VCD_NAME = mask_ru +ID = VCD_VARIABLE_MASK_TX_RU + DESC = VCD variable MASK_TX_RU + GROUP = ALL:VCD:ENB:VCD_VARIABLE + FORMAT = ulong,value + VCD_NAME = mask_tx_ru ID = VCD_VARIABLE_FRAME_NUMBER_TX1_ENB DESC = VCD variable FRAME_NUMBER_TX1_ENB GROUP = ALL:VCD:ENB:VCD_VARIABLE @@ -1863,6 +1873,16 @@ ID = VCD_FUNCTION_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT1 GROUP = ALL:VCD:UE:VCD_FUNCTION FORMAT = int,value VCD_NAME = ue_lock_mutex_rxtx_for_cnt_increment1 +ID = VCD_FUNCTION_LOCK_MUTEX_RU + DESC = VCD function LOCK_MUTEX_RU + GROUP = ALL:VCD:UE:VCD_FUNCTION + FORMAT = int,value + VCD_NAME = lock_mutex_ru +ID = VCD_FUNCTION_LOCK_MUTEX_RU1 + DESC = VCD function LOCK_MUTEX_RU1 + GROUP = ALL:VCD:UE:VCD_FUNCTION + FORMAT = int,value + VCD_NAME = lock_mutex_ru1 ID = VCD_FUNCTION_SIM_DO_DL_SIGNAL DESC = VCD function SIM_DO_DL_SIGNAL GROUP = ALL:VCD:ENB:VCD_FUNCTION diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c index 4898349d12..9ca4bed5de 100644 --- a/targets/RT/USER/lte-enb.c +++ b/targets/RT/USER/lte-enb.c @@ -518,7 +518,7 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) { LOG_E(PHY,"Frame %d, subframe %d: TX FH thread busy, dropping Frame %d, subframe %d\n", ru_proc->frame_tx, ru_proc->subframe_tx, proc->frame_rx, proc->subframe_rx); return(-1); } - if (pthread_mutex_timedlock(&ru_proc->mutex_eNBs,&wait) != 0) { + if (pthread_mutex_lock(&ru_proc->mutex_eNBs) != 0) { LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB TX1 thread %d (IC %d)\n", ru_proc->subframe_rx&1,ru_proc->instance_cnt_eNBs ); exit_fun( "error locking mutex_eNB" ); return(-1); @@ -558,7 +558,7 @@ int wakeup_tx(PHY_VARS_eNB *eNB) { wait.tv_sec=0; wait.tv_nsec=5000000L; - if (pthread_mutex_timedlock(&L1_proc_tx->mutex,&wait) != 0) { + if (pthread_mutex_lock(&L1_proc_tx->mutex) != 0) { LOG_E(PHY, "[SCHED][eNB] ERROR locking mutex for eNB L1_thread_tx\n"); exit_fun("ERROR pthread_lock"); return(-1); @@ -608,7 +608,7 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) { // wake up TX for subframe n+sf_ahead // lock the TX mutex and make sure the thread is ready - if (pthread_mutex_timedlock(&L1_proc->mutex,&wait) != 0) { + if (pthread_mutex_lock(&L1_proc->mutex) != 0) { LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB RXTX thread %d (IC %d)\n", L1_proc->subframe_rx&1,L1_proc->instance_cnt ); exit_fun( "error locking mutex_rxtx" ); return(-1); diff --git a/targets/RT/USER/lte-ru.c b/targets/RT/USER/lte-ru.c index 3513b35c5d..d87bbded17 100644 --- a/targets/RT/USER/lte-ru.c +++ b/targets/RT/USER/lte-ru.c @@ -158,7 +158,7 @@ static inline void fh_if4p5_south_out(RU_t *ru) { if (subframe_select(&ru->frame_parms,ru->proc.subframe_tx)!=SF_UL) { send_IF4p5(ru,ru->proc.frame_tx, ru->proc.subframe_tx, IF4p5_PDLFFT); ru->south_out_cnt++; - printf("south_out_cnt %d, frame %d, subframe %d, RU %d\n",ru->south_out_cnt,ru->proc.frame_tx,ru->proc.subframe_tx,ru->idx); + //printf("south_out_cnt %d, frame %d, subframe %d, RU %d\n",ru->south_out_cnt,ru->proc.frame_tx,ru->proc.subframe_tx,ru->idx); } /*if (ru == RC.ru[0] || ru == RC.ru[1]) { VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU+ru->idx, ru->proc.frame_tx ); @@ -1169,9 +1169,16 @@ void wakeup_L1s(RU_t *ru) { VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); - AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1"); - printf("wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", - ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]); +// AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1"); + if (pthread_mutex_lock(&proc->mutex_RU) !=0) { + LOG_E( PHY, "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1"); + exit_fun( "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1" ); + return(-1); + } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_LOCK_MUTEX_RU+ru->idx, 1 ); + + //printf("wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n", +// ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]); // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); clock_gettime(CLOCK_MONOTONIC,&ru->proc.t[ru->proc.subframe_rx]); @@ -1194,8 +1201,8 @@ void wakeup_L1s(RU_t *ru) { proc->RU_mask[ru->proc.subframe_rx] |= (1<idx,proc->RU_mask[ru->proc.subframe_rx],i); - + //printf("RU %d, RU_mask %d, i %d\n",ru->idx,proc->RU_mask[ru->proc.subframe_rx],i); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_RU, proc->RU_mask[ru->proc.subframe_rx]); if (ru->is_slave == 0 && ( (proc->RU_mask[ru->proc.subframe_rx]&(1<RU_list[i]->state == RU_RUN) { // This is master & the RRU has already been received if (check_sync(eNB->RU_list[i],eNB->RU_list[0],ru->proc.subframe_rx) == 0) LOG_E(PHY,"RU %d is not SYNC, subframe %d, time %f this is master\n", eNB->RU_list[i]->idx, ru->proc.subframe_rx, fabs(eNB->RU_list[i]->proc.t[ru->proc.subframe_rx].tv_nsec - eNB->RU_list[0]->proc.t[ru->proc.subframe_rx].tv_nsec)); @@ -1214,6 +1221,7 @@ void wakeup_L1s(RU_t *ru) { LOG_D(PHY, "ru->proc.subframe_rx is %d \n", ru->proc.subframe_rx); LOG_D(PHY,"Reseting mask frame %d, subframe %d, this is RU %d\n",ru->proc.frame_rx, ru->proc.subframe_rx, ru->idx); proc->RU_mask[ru->proc.subframe_rx] = 0; + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_RU, proc->RU_mask[ru->proc.subframe_rx]); clock_gettime(CLOCK_MONOTONIC,&t); //stop_meas(&proc->ru_arrival_time); AssertFatal(t.tv_nsec < proc->t[ru->proc.subframe_rx].tv_nsec+5000000, @@ -1222,7 +1230,13 @@ void wakeup_L1s(RU_t *ru) { // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx); //VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx); - AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2"); +// AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2"); + if (pthread_mutex_unlock(&proc->mutex_RU) !=0) { + LOG_E( PHY, "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2"); + exit_fun( "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2" ); + return(-1); + } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_LOCK_MUTEX_RU+ru->idx, 0 ); // unlock RUs that are waiting for eNB processing to be completed LOG_D(PHY,"RU %d wakeup eNB top for subframe %d\n", ru->idx,ru->proc.subframe_rx); @@ -1248,8 +1262,14 @@ void wakeup_L1s(RU_t *ru) { } else{ // not all RUs have provided their information - AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3"); +// AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3"); + if (pthread_mutex_unlock(&proc->mutex_RU) !=0) { + LOG_E( PHY, "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3"); + exit_fun( "RE MALAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3" ); + return(-1); } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_LOCK_MUTEX_RU+ru->idx, 0 ); + } // pthread_mutex_unlock(&proc->mutex_RU); // LOG_D(PHY,"wakeup eNB top for for subframe %d\n", ru->proc.subframe_rx); // ru->eNB_top(eNB_list[0],ru->proc.frame_rx,ru->proc.subframe_rx,string); @@ -1575,15 +1595,17 @@ static void* ru_thread_tx( void* param ) { eNB_proc->RU_mask_tx |= (1<idx,eNB_proc->RU_mask_tx,L1_proc->subframe_tx); + //printf("RU_id %d, RU_mask_tx %d, subframe_tx %d\n",ru->idx,eNB_proc->RU_mask_tx,L1_proc->subframe_tx); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU, eNB_proc->RU_mask_tx); } if (eNB_proc->RU_mask_tx != (1<num_RU)-1) { // not all RUs have provided their information so return - printf("Not all RUs have provided their info (mask = %d), RU %d, num_RUs %d\n", eNB_proc->RU_mask_tx,ru->idx,eNB->num_RU); + //printf("Not all RUs have provided their info (mask = %d), RU %d, num_RUs %d\n", eNB_proc->RU_mask_tx,ru->idx,eNB->num_RU); pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); } else { // all RUs TX are finished so send the ready signal to eNB processing - printf("All RUs TX are finished. Ready to send wakeup signal to eNB processing, num_RUs %d, RU %d, mask %d\n", eNB->num_RU,ru->idx,eNB_proc->RU_mask_tx); + //printf("All RUs TX are finished. Ready to send wakeup signal to eNB processing, num_RUs %d, RU %d, mask %d\n", eNB->num_RU,ru->idx,eNB_proc->RU_mask_tx); eNB_proc->RU_mask_tx = 0; + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_MASK_TX_RU, eNB_proc->RU_mask_tx); pthread_mutex_unlock(&eNB_proc->mutex_RU_tx); pthread_mutex_lock( &L1_proc->mutex_RUs);