X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2F5gnrsch%2Fsch_tmr.c;h=fa716742edfcf49c9f95ac627eec47239034e00c;hb=refs%2Fchanges%2F60%2F11760%2F2;hp=e880db0acdcc2aef2e9b83fce7b14ff6788183f3;hpb=d75d1b078091768f45b83f2a745a25917e03b39d;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch_tmr.c b/src/5gnrsch/sch_tmr.c index e880db0ac..fa716742e 100644 --- a/src/5gnrsch/sch_tmr.c +++ b/src/5gnrsch/sch_tmr.c @@ -21,6 +21,220 @@ #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; + +#ifdef DEBUG_PRINT + DU_LOG("\nDEBUG --> SCH : Starting Timer Event [%d] with Wait Time [%d] ms", \ + tmrEvnt, timerValue); +#endif + + 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; + +#ifdef DEBUG_PRINT + DU_LOG("\nDEBUG --> SCH : Stopping Timer Event [%d]", tmrType); +#endif + + 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) +{ + double percentageOfTotalPrbUsed = 0; + + if(dlTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((100.0 * dlTotalPrbUsage->numPrbUsedForTx) / 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) +{ + double percentageOfTotalPrbUsed = 0; + + if(ulTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((100.0 * ulTotalPrbUsage->numPrbUsedForTx) / 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 +248,34 @@ * 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 */ +#ifdef DEBUG_PRINT + DU_LOG("\nDEBUG --> SCH : Timer Expired. Event [%d]", tmrEvnt); +#endif + + 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 +300,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;