X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2F5gnrsch%2Fsch_tmr.c;fp=src%2F5gnrsch%2Fsch_tmr.c;h=e31c5182a6ab8a023d5a1374b447e9d0122f0aa9;hb=f73456bd55152c329601f8286ae67fe9875025bc;hp=e880db0acdcc2aef2e9b83fce7b14ff6788183f3;hpb=ab13dee0decf8731b1d95f943d13a6e7a4a2ead5;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch_tmr.c b/src/5gnrsch/sch_tmr.c index e880db0ac..e31c5182a 100644 --- a/src/5gnrsch/sch_tmr.c +++ b/src/5gnrsch/sch_tmr.c @@ -21,6 +21,216 @@ #include "lrg.x" #include "mac_sch_interface.h" #include "sch.h" +#include "sch_tmr.h" + +/** + * @brief Handler to check if the timer is running + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Bool indicating whether the timer is running or not + * -# ROK + * -# RFAILED +*/ +bool schChkTmr(PTR cb, int16_t tmrEvnt) +{ + switch (tmrEvnt) + { + case EVENT_DL_TOTAL_PRB_USAGE_TMR: + { + if(((TotalPrbUsage *)cb)->periodTimer.tmrEvnt == EVENT_DL_TOTAL_PRB_USAGE_TMR) + { + DU_LOG("\nDEBUG --> SCH : schChkTmr: Timer Evnt [%d] already running", tmrEvnt); + return TRUE; + } + break; + } + + case EVENT_UL_TOTAL_PRB_USAGE_TMR: + { + if(((TotalPrbUsage *)cb)->periodTimer.tmrEvnt == EVENT_UL_TOTAL_PRB_USAGE_TMR) + { + DU_LOG("\nDEBUG --> SCH : schChkTmr: Timer Evnt [%d] already running", tmrEvnt); + return TRUE; + } + break; + } + + default: + { + DU_LOG("\nERROR --> SCH : schChkTmr: Invalid tmr Evnt [%d]", tmrEvnt); + } + } + + return FALSE; +} + +/** + * @brief Handler to start timer + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Void +*/ +void schStartTmr(SchCb *gCb, PTR cb, int16_t tmrEvnt, uint8_t timerValue) +{ + TotalPrbUsage *dlTotalPrbUsage; + TotalPrbUsage *ulTotalPrbUsage; + CmTmrArg arg; + + arg.wait = 0; + + DU_LOG("\nINFO --> SCH : Starting Timer Event [%d] with Wait Time [%d] ms", \ + tmrEvnt, timerValue); + + switch (tmrEvnt) + { + case EVENT_DL_TOTAL_PRB_USAGE_TMR: + { + dlTotalPrbUsage = ((TotalPrbUsage *)cb); + TMR_CALCUATE_WAIT(arg.wait, timerValue, gCb->schTimersInfo.tmrRes); + + arg.timers = &dlTotalPrbUsage->periodTimer; + arg.max = MAX_TOTAL_PRB_USAGE_TMR; + break; + } + + case EVENT_UL_TOTAL_PRB_USAGE_TMR: + { + ulTotalPrbUsage = ((TotalPrbUsage *)cb); + TMR_CALCUATE_WAIT(arg.wait, timerValue, gCb->schTimersInfo.tmrRes); + + arg.timers = &ulTotalPrbUsage->periodTimer; + arg.max = MAX_TOTAL_PRB_USAGE_TMR; + break; + } + default: + { + DU_LOG("\nERROR --> SCH : schStartTmr: Invalid tmr Evnt [%d]", tmrEvnt); + } + } + + if(arg.wait != 0) + { + arg.tqCp = &(gCb->schTimersInfo.tmrTqCp); + arg.tq = gCb->schTimersInfo.tmrTq; + arg.cb = cb; + arg.evnt = tmrEvnt; + arg.tNum = 0; + + cmPlcCbTq(&arg); + } + + return; +} + +/** + * @brief Handler to stop a timer + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrType Timer event to be started + * + * @return Void +*/ +void schStopTmr(SchCb *gCb, PTR cb, uint8_t tmrType) +{ + CmTmrArg arg; + + arg.timers = NULLP; + + DU_LOG("\nINFO --> SCH : Stopping Timer Event [%d]", tmrType); + + switch (tmrType) + { + case EVENT_DL_TOTAL_PRB_USAGE_TMR: + { + arg.timers = &((TotalPrbUsage *)cb)->periodTimer; + arg.max = MAX_TOTAL_PRB_USAGE_TMR; + break; + } + case EVENT_UL_TOTAL_PRB_USAGE_TMR: + { + arg.timers = &((TotalPrbUsage *)cb)->periodTimer; + arg.max = MAX_TOTAL_PRB_USAGE_TMR; + break; + } + + default: + { + DU_LOG("\nERROR --> SCH : schStopTmr: Invalid tmr Evnt[%d]", tmrType); + break; + } + } + + if (tmrType != TMR0) + { + arg.tqCp = &gCb->schTimersInfo.tmrTqCp; + arg.tq = gCb->schTimersInfo.tmrTq; + arg.cb = cb; + arg.evnt = tmrType; + arg.wait = 0; + arg.tNum = 0; + cmRmvCbTq(&arg); + } + + return; +} + +/** + * @brief Handler to process Timer expiry of DL Total PRB Usage calculation + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Bool indicating whether the timer is running or not + * -# ROK + * -# RFAILED +*/ +uint8_t SchProcDlTotalPrbUsageTmrExp(TotalPrbUsage *dlTotalPrbUsage) +{ + uint8_t percentageOfTotalPrbUsed = 0; + + if(dlTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((dlTotalPrbUsage->numPrbUsedForTx * 100) / dlTotalPrbUsage->totalPrbAvailForTx); + //SchSendStatsIndToMac(dlTotalPrbUsage->schInst, SCH_DL_TOTAL_PRB_USAGE, percentageOfTotalPrbUsed); + + /* Restart Timer */ + dlTotalPrbUsage->numPrbUsedForTx = 0; + dlTotalPrbUsage->totalPrbAvailForTx = 0; + schStartTmr(&schCb[dlTotalPrbUsage->schInst], (PTR)(dlTotalPrbUsage), EVENT_DL_TOTAL_PRB_USAGE_TMR, \ + dlTotalPrbUsage->periodicity); + + return ROK; +} + +/** + * @brief Handler to check if the timer is running + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Bool indicating whether the timer is running or not + * -# ROK + * -# RFAILED +*/ +uint8_t SchProcUlTotalPrbUsageTmrExp(TotalPrbUsage *ulTotalPrbUsage) +{ + uint8_t percentageOfTotalPrbUsed = 0; + + if(ulTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((ulTotalPrbUsage->numPrbUsedForTx * 100) / ulTotalPrbUsage->totalPrbAvailForTx); + //SchSendStatsIndToMac(ulTotalPrbUsage->schInst, SCH_UL_TOTAL_PRB_USAGE, percentageOfTotalPrbUsed); + + /* Restart Timer */ + ulTotalPrbUsage->numPrbUsedForTx = 0; + ulTotalPrbUsage->totalPrbAvailForTx = 0; + schStartTmr(&schCb[ulTotalPrbUsage->schInst], (PTR)(ulTotalPrbUsage), EVENT_UL_TOTAL_PRB_USAGE_TMR, \ + ulTotalPrbUsage->periodicity); + + return ROK; +} /** * @brief Timer Expiry handler. @@ -34,13 +244,37 @@ * about tmrEvnt=Bind timer. * * @param[in] PTR cb, Entry for which Timer expired - * @param[in] S16 tmrEvnt, the Timer Event + * @param[in] uint8_t tmrEvnt, the Timer Event * @return uint8_t * -# ROK **/ uint8_t schTmrExpiry(PTR cb, uint8_t tmrEvnt) { - /* TODO : Handling of any timer event expiry */ + DU_LOG("\nINFO --> SCH : Timer Event [%d] expired", tmrEvnt); + + struct timeval tp; + gettimeofday(&tp, 0); + time_t curtime = tp.tv_sec; + struct tm *t = localtime(&curtime); + + switch (tmrEvnt) + { + case EVENT_DL_TOTAL_PRB_USAGE_TMR: + { + SchProcDlTotalPrbUsageTmrExp((TotalPrbUsage*)cb); + break; + } + case EVENT_UL_TOTAL_PRB_USAGE_TMR: + { + SchProcUlTotalPrbUsageTmrExp((TotalPrbUsage*)cb); + break; + } + default: + { + DU_LOG("\nERROR --> DU : duStartTmr: Invalid tmr Evnt [%d]", tmrEvnt); + break; + } + } return ROK; } @@ -65,8 +299,7 @@ short int schActvTmr(Ent ent,Inst inst) Inst schInst = (inst - SCH_INST_START); /* Check if any timer in the scheduler instance has expired */ - cmPrcTmr(&schCb[schInst].tmrTqCp, - schCb[schInst].tmrTq, (PFV) schTmrExpiry); + cmPrcTmr(&schCb[schInst].schTimersInfo.tmrTqCp, schCb[schInst].schTimersInfo.tmrTq, (PFV) schTmrExpiry); return ROK;