X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=fhi_lib%2Flib%2Fsrc%2Fxran_timer.c;h=0b86f8eb81ebeab2a554e0ebce3a54dd58b7be12;hb=70d9d920dd4e575f085f1f1a9050fefd1c10e127;hp=875b0b679e560ba63d01219acadb7f6e6c3b3b0e;hpb=4745e5c88ba931c6d71cb6d8c681f76cf364eac5;p=o-du%2Fphy.git diff --git a/fhi_lib/lib/src/xran_timer.c b/fhi_lib/lib/src/xran_timer.c index 875b0b6..0b86f8e 100644 --- a/fhi_lib/lib/src/xran_timer.c +++ b/fhi_lib/lib/src/xran_timer.c @@ -16,7 +16,6 @@ * *******************************************************************************/ - /** * @brief This file provides implementation to Timing for XRAN. * @@ -33,46 +32,76 @@ #include "xran_timer.h" #include "xran_printf.h" -#ifndef MLOG_ENABLED -#include "mlog_lnx_xRAN.h" -#else -#include "mlog_lnx.h" -#endif +#include "xran_mlog_lnx.h" #include "xran_lib_mlog_tasks_id.h" #include "ethdi.h" +#include "xran_fh_o_du.h" +#include "xran_common.h" #define NSEC_PER_SEC 1000000000L #define NSEC_PER_USEC 1000L #define THRESHOLD 35 /**< the avg cost of clock_gettime() in ns */ #define TIMECOMPENSATION 2 /**< time compensation in us, avg latency of clock_nanosleep */ -#define SEC_MOD_STOP (30) +#define SEC_MOD_STOP (60) static struct timespec started_time; static struct timespec last_time; static struct timespec cur_time; +static uint64_t curr_tick; +static uint64_t last_tick; + static struct timespec* p_cur_time = &cur_time; static struct timespec* p_last_time = &last_time; + static struct timespec* p_temp_time; +static struct timespec sleeptime = {.tv_nsec = 1E3 }; /* 1 us */ + static unsigned long current_second = 0; static unsigned long started_second = 0; +static uint8_t numerlogy = 0; extern uint32_t xran_lib_ota_sym; extern uint32_t xran_lib_ota_tti; extern uint32_t xran_lib_ota_sym_idx; static int debugStop = 0; +static int debugStopCount = 0; + +static long fine_tuning[5][2] = +{ + {71428L, 71429L}, /* mu = 0 */ + {35714L, 35715L}, /* mu = 1 */ + {0, 0}, /* mu = 2 not supported */ + {8928L, 8929L}, /* mu = 3 */ + {0,0 } /* mu = 4 not supported */ +}; + +static uint8_t slots_per_subframe[4] = +{ + 1, /* mu = 0 */ + 2, /* mu = 1 */ + 4, /* mu = 2 */ + 8, /* mu = 3 */ +}; uint64_t timing_get_current_second(void) { return current_second; } -int timing_set_debug_stop(int value) +int timing_set_numerology(uint8_t value) +{ + numerlogy = value; + return numerlogy; +} + +int timing_set_debug_stop(int value, int count) { debugStop = value; + debugStopCount = count; if(debugStop){ clock_gettime(CLOCK_REALTIME, &started_time); @@ -86,29 +115,78 @@ int timing_get_debug_stop(void) return debugStop; } -long poll_next_tick(long interval_ns) +void timing_adjust_gps_second(struct timespec* p_time) +{ + struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx(); + + if (p_time->tv_nsec >= p_xran_dev_ctx->offset_nsec) + { + p_time->tv_nsec -= p_xran_dev_ctx->offset_nsec; + p_time->tv_sec -= p_xran_dev_ctx->offset_sec; + } + else + { + p_time->tv_nsec += 1e9 - p_xran_dev_ctx->offset_nsec; + p_time->tv_sec -= p_xran_dev_ctx->offset_sec + 1; + } + + return; +} +uint64_t xran_tick(void) { + uint32_t hi, lo; + __asm volatile ("rdtsc" : "=a"(lo), "=d"(hi)); + return ( (uint64_t)lo)|( ((uint64_t)hi)<<32 ); +} + +unsigned long get_ticks_diff(unsigned long curr_tick, unsigned long last_tick) +{ + if (curr_tick >= last_tick) + return (unsigned long)(curr_tick - last_tick); + else + return (unsigned long)(0xFFFFFFFFFFFFFFFF - last_tick + curr_tick); +} + +long poll_next_tick(long interval_ns, unsigned long *used_tick) +{ + struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx(); + struct xran_common_counters* pCnt = &p_xran_dev_ctx->fh_counters; + long target_time; long delta; static int counter = 0; static long sym_acc = 0; static long sym_cnt = 0; - if(counter){ + if(counter == 0) { clock_gettime(CLOCK_REALTIME, p_last_time); + last_tick = MLogTick(); + if(unlikely(p_xran_dev_ctx->offset_sec || p_xran_dev_ctx->offset_nsec)) + timing_adjust_gps_second(p_last_time); current_second = p_last_time->tv_sec; counter = 1; } target_time = (p_last_time->tv_sec * NSEC_PER_SEC + p_last_time->tv_nsec + interval_ns); - while(1) - { + while(1) { clock_gettime(CLOCK_REALTIME, p_cur_time); + curr_tick = MLogTick(); + if(unlikely(p_xran_dev_ctx->offset_sec || p_xran_dev_ctx->offset_nsec)) + timing_adjust_gps_second(p_cur_time); delta = (p_cur_time->tv_sec * NSEC_PER_SEC + p_cur_time->tv_nsec) - target_time; if(delta > 0 || (delta < 0 && abs(delta) < THRESHOLD)) { + if (debugStop &&(debugStopCount > 0) && (pCnt->tx_counter >= debugStopCount)){ + uint64_t t1; + printf("STOP:[%ld.%09ld], debugStopCount %d, tx_counter %ld\n", p_cur_time->tv_sec, p_cur_time->tv_nsec, debugStopCount, pCnt->tx_counter); + t1 = MLogTick(); + rte_pause(); + MLogTask(PID_TIME_SYSTIME_STOP, t1, MLogTick()); + xran_if_current_state = XRAN_STOPPED; + } if(current_second != p_cur_time->tv_sec){ current_second = p_cur_time->tv_sec; + xran_updateSfnSecStart(); xran_lib_ota_sym_idx = 0; xran_lib_ota_tti = 0; xran_lib_ota_sym = 0; @@ -127,12 +205,12 @@ long poll_next_tick(long interval_ns) } p_cur_time->tv_nsec = 0; // adjust to 1pps } else { - xran_lib_ota_sym_idx = XranIncrementSymIdx(xran_lib_ota_sym_idx, 14*8); + xran_lib_ota_sym_idx = XranIncrementSymIdx(xran_lib_ota_sym_idx, XRAN_NUM_OF_SYMBOL_PER_SLOT*slots_per_subframe[numerlogy]); /* adjust to sym boundary */ if(sym_cnt & 1) - sym_acc += 8928L; + sym_acc += fine_tuning[numerlogy][0]; else - sym_acc += 8929L; + sym_acc += fine_tuning[numerlogy][1]; /* fine tune to second boundary */ if(sym_cnt % 13 == 0) sym_acc += 1; @@ -140,12 +218,38 @@ long poll_next_tick(long interval_ns) p_cur_time->tv_nsec = sym_acc; sym_cnt++; } + +#ifdef USE_PTP_TIME if(debugStop && delta < interval_ns*10) MLogTask(PID_TIME_SYSTIME_POLL, (p_last_time->tv_sec * NSEC_PER_SEC + p_last_time->tv_nsec), (p_cur_time->tv_sec * NSEC_PER_SEC + p_cur_time->tv_nsec)); +#else + MLogTask(PID_TIME_SYSTIME_POLL, last_tick, curr_tick); + last_tick = curr_tick; +#endif + + p_temp_time = p_last_time; p_last_time = p_cur_time; p_cur_time = p_temp_time; break; + } else { + if( likely(xran_if_current_state == XRAN_RUNNING)){ + uint64_t t1, t2; + t1 = xran_tick(); + + if(p_xran_dev_ctx->fh_init.io_cfg.pkt_proc_core == 0) + ring_processing_func(); + + process_dpdk_io(); + + /* work around for some kernel */ + if(p_xran_dev_ctx->fh_init.io_cfg.io_sleep) + nanosleep(&sleeptime,NULL); + + t2 = xran_tick(); + *used_tick += get_ticks_diff(t2, t1); + } + } }