From 9fd2f2ab1c817f48e988f5524e4a9f9d10ae1f92 Mon Sep 17 00:00:00 2001 From: "lal.harshita" Date: Tue, 29 Nov 2022 22:21:37 +0530 Subject: [PATCH] [Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Implementation of Ul Harq Rtt timer and Ul harq Retransmission timer Signed-off-by: lal.harshita Change-Id: I9478e4d6e5bb3e88cf6006945ed1dd966fb98c96 Signed-off-by: lal.harshita --- src/5gnrsch/sch_common.c | 16 +- src/5gnrsch/sch_drx.c | 374 ++++++++++++++++++++++++++++++++++++++++++- src/5gnrsch/sch_drx.h | 3 + src/5gnrsch/sch_harq_ul.c | 16 +- src/5gnrsch/sch_slot_ind.c | 6 + src/du_app/du_f1ap_msg_hdl.c | 3 +- src/du_app/du_mgr_main.c | 12 +- 7 files changed, 412 insertions(+), 18 deletions(-) diff --git a/src/5gnrsch/sch_common.c b/src/5gnrsch/sch_common.c index 72a12c254..f98610a76 100644 --- a/src/5gnrsch/sch_common.c +++ b/src/5gnrsch/sch_common.c @@ -413,18 +413,20 @@ uint16_t fillPucchResourceInfo(SchPucchInfo *schPucchInfo, Inst inst, SlotTiming SchCellCb *cell = schCb[inst].cells[inst]; SchPucchCfgCmn *pucchCfg = NULLP; SchBwpParams *ulBwp = NULLP; +#ifdef NR_DRX SchUeCb *ueCb = NULLP; +#endif uint16_t startPrb; GET_UE_ID(schPucchInfo->rnti, ueId); ueIdx = ueId -1; #ifdef NR_DRX - ueCb = schGetUeCb(cell, schPucchInfo->rnti); - if(ueCb->ueDrxInfoPres) - { - if(!ueCb->drxUeCb.drxUlUeActiveStatus) - return RFAILED; - } + ueCb = schGetUeCb(cell, schPucchInfo->rnti); + if(ueCb->ueDrxInfoPres) + { + if(!ueCb->drxUeCb.drxUlUeActiveStatus) + return RFAILED; + } #endif if(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres) { @@ -479,7 +481,9 @@ uint16_t fillPucchResourceInfo(SchPucchInfo *schPucchInfo, Inst inst, SlotTiming uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst) { int ret = ROK; +#ifdef NR_DRX SchUeCb *ueCb; +#endif UlSchedInfo ulSchedInfo; SchUlSlotInfo *schUlSlotInfo = NULLP; SlotTimingInfo ulTimingInfo; diff --git a/src/5gnrsch/sch_drx.c b/src/5gnrsch/sch_drx.c index 6230ccb20..911af3c68 100644 --- a/src/5gnrsch/sch_drx.c +++ b/src/5gnrsch/sch_drx.c @@ -953,6 +953,7 @@ void schHandleStartDrxTimer(SchCellCb *cell) /* Handling the onduration start timer */ schHdlDrxOnDurStrtTimer(cell); schHdlDrxDlHqRetxStrtTimer(cell); + schHdlDrxUlHqRetxStrtTimer(cell); } /** @@ -982,6 +983,146 @@ void schDrxStrtDlHqRttTmr(SchDlHqProcCb *hqP) schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].dlHarqRttExpiryList, hqP, &hqP->dlDrxHarqCb.rttExpNode); } +/** + * @brief Handling of the Ul harq DRX timers start for Dl scheduling + * + * @details + * + * Function : schHdlUlHqRetxStrtTimerForDl + * + * Handling of Ul harq DRX timers start for Dl scheduling + * + * @param[in] SchCellCb *cell, uint16_t currIdx + * @return + * void +**/ + +void schHdlUlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx) +{ + uint32_t retxExpIndx; + CmLList *currNode; + SchUlHqProcCb *hqP; + SchUeCb *ueCb; + + currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first; + + while(currNode) + { + hqP = (SchUlHqProcCb*)currNode->node; + currNode = currNode->next; + addUeToBeScheduled(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId); + ueCb = hqP->hqEnt->ue; + + /* calculate the retransmission exp index */ + retxExpIndx = (currIndx + ueCb->drxUeCb.retransUlTimerLen)%MAX_DRX_SIZE; + if(hqP->ulDrxHarqCb.retxExpIndex == SCH_DRX_INVALID_INDEX) + { + hqP->ulDrxHarqCb.retxExpIndex = retxExpIndx; + schAddDrxNodeIntoHarqTimerList(&cell->drxCb[retxExpIndx].ulRetransExpiryList, hqP, &hqP->ulDrxHarqCb.retxExpNode); + } + + /* Mark the UE active for downlink */ + ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId); + setDrxUeStatusForDlandUl(&ueCb->drxUeCb); + } +} + +/** + * @brief Handling of the Ul harq DRX timers start for Ul scheduling + * + * @details + * + * Function : schHdlUlHqRetxStrtTimerForUl + * + * Handling of Ul harq DRX timers start for Ul scheduling + * + * @param[in] SchCellCb *cell, uint16_t currIdx + * @return + * void + **/ + +void schHdlUlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx) +{ + CmLList *currNode; + SchUlHqProcCb *hqP; + SchUeCb *ueCb; + + currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first; + + while(currNode) + { + hqP = (SchUlHqProcCb*)currNode->node; + currNode = currNode->next; + ueCb = hqP->hqEnt->ue; + + /* Mark the UE active for uplink */ + ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId); + setDrxUeStatusForDlandUl(&ueCb->drxUeCb); + + /* Delete the node */ + cmLListDelFrm(&cell->drxCb[currIndx].ulRetransTmrStartList, hqP->ulDrxHarqCb.retxStrtNode); + SCH_FREE(hqP->ulDrxHarqCb.retxStrtNode, sizeof(CmLList)); + hqP->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX; + } +} + +/** + * @brief Handling of the Ul harq DRX timers start + * + * @details + * + * Function : schHdlDrxUlHqRetxStrtTimer + * + * Handling of Ul harq DRX timers start + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED + **/ + +void schHdlDrxUlHqRetxStrtTimer(SchCellCb *cell) +{ + uint16_t dlIndx = 0, ulIndx=0; + SlotTimingInfo dlSlotInfo, ulSlotInfo; + + ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots); + ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots); + + dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE; + ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE; + + schHdlUlHqRetxStrtTimerForDl(cell, dlIndx); + schHdlUlHqRetxStrtTimerForUl(cell, ulIndx); +} + +/** + * @brief Handling of the Ul harq Rtt start DRX timers + * + * @details + * + * Function : schDrxStrtUlHqRttTmr + * + * Handling of the Ul harq Rtt start DRX timers + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED + **/ + +void schDrxStrtUlHqRttTmr(SchUlHqProcCb *hqP) +{ + uint16_t harqRttExpTimer=0; + SchDrxUeCb *drxUeCb; + + drxUeCb = &hqP->hqEnt->ue->drxUeCb; + + harqRttExpTimer = (hqP->puschTime.sfn * MAX_SLOTS + hqP->puschTime.slot + drxUeCb->harqRttUlTimerLen)%MAX_DRX_SIZE; + hqP->ulDrxHarqCb.rttExpIndex = harqRttExpTimer; + schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].ulHarqRttExpiryList, hqP, &hqP->ulDrxHarqCb.rttExpNode); +} + /** * @brief Handling of the expiry onduration timer in dl direction * @@ -1490,7 +1631,7 @@ void schHdlDlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx) * * @details * - * Function : schHdlDrxHarqExpireTimer + * Function : schHdlDrxDlHarqExpireTimer * * Handling of expiry of Dl harq DRX timers * @@ -1500,7 +1641,7 @@ void schHdlDlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx) **/ -void schHdlDrxHarqExpireTimer(SchCellCb *cell) +void schHdlDrxDlHarqExpireTimer(SchCellCb *cell) { uint16_t dlIndx = 0, ulIndx = 0; SlotTimingInfo dlSlotInfo, ulSlotInfo; @@ -1564,6 +1705,232 @@ void schDrxStopDlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchDlHqProcCb **hqP) } } +/** + * @brief Handling of the expiry Ul harq rrt DRX timers + * + * @details + * + * Function : schHdlUlHqRttExpiryTimerForDl + * + * Handling of expiry ul harq rrt DRX timers + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED + **/ + +void schHdlUlHqRttExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx) +{ + SchUlHqProcCb *hqP; + CmLList *drxCurrNode; + + drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first; + + while(drxCurrNode) + { + hqP = (SchUlHqProcCb*)drxCurrNode->node; + drxCurrNode = drxCurrNode->next; + + /* Add ue to ulRetransTmrStartList list */ + if(hqP->ulDrxHarqCb.retxStrtIndex == SCH_DRX_INVALID_INDEX) + { + schAddDrxNodeIntoHarqTimerList(&cell->drxCb[currIdx + 1].ulRetransTmrStartList, hqP, &hqP->ulDrxHarqCb.retxStrtNode); + hqP->ulDrxHarqCb.retxStrtIndex = currIdx + 1; + } + } +} + +/** + * @brief Handling of the expiry ul harq retransmission DRX timers + * + * @details + * + * Function : schHdlUlHqRetxExpiryTimerForDl + * + * Handling of expiry Ul harq retransmission DRX timers + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED +**/ + +void schHdlUlHqRetxExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx) +{ + SchUlHqProcCb *hqP; + SchUeCb *ueCb; + CmLList *drxCurrNode; + + drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first; + + while(drxCurrNode) + { + hqP = (SchUlHqProcCb*)drxCurrNode->node; + drxCurrNode = drxCurrNode->next; + ueCb = hqP->hqEnt->ue; + + ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId); + + /* Set the Ue status as inactive */ + setDrxUeStatusForDlandUl(&ueCb->drxUeCb); + } +} + +/** + * @brief Handling of the expiry ul harq rrt DRX timers for Ul scheduling + * + * @details + * + * Function : schHdlUlHqRttExpiryTimerForUl + * + * Handling of expiry Ul harq rrt DRX timers for Ul scheduling + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED +**/ + +void schHdlUlHqRttExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx) +{ + SchUlHqProcCb *hqP; + CmLList *drxCurrNode; + + drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first; + + while(drxCurrNode) + { + hqP = (SchUlHqProcCb*)drxCurrNode->node; + drxCurrNode = drxCurrNode->next; + + /* Delete the node from list */ + cmLListDelFrm(&cell->drxCb[currIdx].ulHarqRttExpiryList, hqP->ulDrxHarqCb.rttExpNode); + SCH_FREE(hqP->ulDrxHarqCb.rttExpNode, sizeof(CmLList)); + hqP->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX; + } +} + +/** + * @brief Handling of the expiry Ul harq retransmission DRX timers for Ul scheduling + * + * @details + * + * Function : schHdlUlHqRetxExpiryTimerForUl + * + * Handling of expiry Ul harq retransmission DRX timers for Ul scheduling + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED +**/ + +void schHdlUlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx) +{ + SchUlHqProcCb *hqP; + SchUeCb *ueCb; + CmLList *drxCurrNode; + + drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first; + + while(drxCurrNode) + { + hqP = (SchUlHqProcCb*)drxCurrNode->node; + ueCb = hqP->hqEnt->ue; + drxCurrNode = drxCurrNode->next; + + /* Set the Ue status as inactive for uplink */ + ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId); + setDrxUeStatusForDlandUl(&ueCb->drxUeCb); + + /* Delete the UE */ + cmLListDelFrm(&cell->drxCb[currIdx].ulRetransExpiryList, hqP->ulDrxHarqCb.retxExpNode); + SCH_FREE(hqP->ulDrxHarqCb.retxExpNode, sizeof(CmLList)); + hqP->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX; + + } +} + +/** + * @brief Handling of the expiry of Ul harq DRX timers + * + * @details + * + * Function : schHdlDrxUlHarqExpireTimer + * + * Handling of expiry of Ul harq DRX timers + * + * @param[in] SchCellCb *cell + * @return + * -# void + + **/ + +void schHdlDrxUlHarqExpireTimer(SchCellCb *cell) +{ + uint16_t dlIndx = 0, ulIndx = 0; + SlotTimingInfo dlSlotInfo, ulSlotInfo; + + ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots); + ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots); + dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE; + ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE; + + schHdlUlHqRttExpiryTimerForDl(cell, dlIndx); + schHdlUlHqRetxExpiryTimerForDl(cell, dlIndx); + schHdlUlHqRttExpiryTimerForUl(cell, ulIndx ); + schHdlUlHqRetxExpiryTimerForUl(cell, ulIndx); +} + +/** + * @brief Hanuling of the expiry of harq DRX timers + * + * @details + * + * Function : schDrxStopUlHqRetxTmr + * + * Hanuling of expiry DRX timers + * + * @param[in] SchCellCb *cell + * @return + * -# ROK + * -# RFAILED + **/ + +void schDrxStopUlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchUlHqProcCb **hqP) +{ + + if((*hqP)->ulDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX) + { + ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << (*hqP)->procId); + ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << (*hqP)->procId); + + /* Change the UE status to Inactive */ + setDrxUeStatusForDlandUl(&ueCb->drxUeCb); + + /* If there is any node present in rtt list then remove the node from list */ + if((*hqP)->ulDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX) + { + cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.rttExpIndex].ulHarqRttExpiryList, (*hqP)->ulDrxHarqCb.rttExpNode); + SCH_FREE((*hqP)->ulDrxHarqCb.rttExpNode, sizeof(CmLList)); + (*hqP)->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX; + } + + /* If there is any node present in retx list then remove the node from list */ + if((*hqP)->ulDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX) + { + cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxStrtIndex].ulRetransTmrStartList, (*hqP)->ulDrxHarqCb.retxStrtNode); + SCH_FREE((*hqP)->ulDrxHarqCb.retxStrtNode, sizeof(CmLList)); + (*hqP)->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX; + } + + cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxExpIndex].ulRetransExpiryList, (*hqP)->ulDrxHarqCb.retxExpNode); + SCH_FREE((*hqP)->ulDrxHarqCb.retxExpNode, sizeof(CmLList)); + (*hqP)->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX; + } +} + /** * @brief Handling of the expiry DRX timers * @@ -1584,7 +1951,8 @@ void schHandleExpiryDrxTimer(SchCellCb *cell) schHdlDrxShortCycleExpiryTimer(cell); schHdlDrxOnDurExpiryTimer(cell); schHdlDrxInActvExpiryTimer(cell); - schHdlDrxHarqExpireTimer(cell); + schHdlDrxDlHarqExpireTimer(cell); + schHdlDrxUlHarqExpireTimer(cell); } #endif diff --git a/src/5gnrsch/sch_drx.h b/src/5gnrsch/sch_drx.h index d4c9d99e5..d5dbf6140 100644 --- a/src/5gnrsch/sch_drx.h +++ b/src/5gnrsch/sch_drx.h @@ -63,6 +63,9 @@ void schHdlDrxOnDurExpiryTimer(SchCellCb *cell); void schHandleExpiryDrxTimer(SchCellCb *cell); void schDrxStrtDlHqRttTmr(SchDlHqProcCb *hqP); void schDrxStopDlHqRetxTmr(SchCellCb *cell, SchUeCb *uecb, SchDlHqProcCb **hqP); +void schDrxStopUlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchUlHqProcCb **hqP); +void schDrxStrtUlHqRttTmr(SchUlHqProcCb *hqP); +void schHdlDrxUlHqRetxStrtTimer(SchCellCb *cell); /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrsch/sch_harq_ul.c b/src/5gnrsch/sch_harq_ul.c index fdd5ffa5a..55c9b44c8 100644 --- a/src/5gnrsch/sch_harq_ul.c +++ b/src/5gnrsch/sch_harq_ul.c @@ -25,6 +25,9 @@ #include "mac_sch_interface.h" #include "sch.h" #include "sch_utils.h" +#ifdef NR_DRX +#include "sch_drx.h" +#endif typedef struct schCellCb SchCellCb; typedef struct schUeCb SchUeCb; void schUlHqEntReset(SchCellCb *cellCb, SchUeCb *ueCb, SchUlHqEnt *hqE); @@ -237,7 +240,16 @@ void schUlHqProcessNack(SchUlHqProcCb *hqP) if (hqP->tbInfo.txCntr < hqP->maxHqTxPerHqP) { cmLListAdd2Tail(&(hqP->hqEnt->ue->ulRetxHqList), &hqP->ulHqProcLink); - addUeToBeScheduled(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId); +#ifdef NR_DRX + if(hqP->hqEnt->ue->ueDrxInfoPres == true) + { + schDrxStrtUlHqRttTmr(hqP); + } + else +#endif + { + addUeToBeScheduled(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId); + } } else { @@ -263,4 +275,4 @@ void schUlHqProcessAck(SchUlHqProcCb *hqP) } /********************************************************************** End of file - **********************************************************************/ \ No newline at end of file + **********************************************************************/ diff --git a/src/5gnrsch/sch_slot_ind.c b/src/5gnrsch/sch_slot_ind.c index c0b67c71a..d3e28fd03 100644 --- a/src/5gnrsch/sch_slot_ind.c +++ b/src/5gnrsch/sch_slot_ind.c @@ -958,6 +958,12 @@ uint8_t schProcessSlotInd(SlotTimingInfo *slotInd, Inst schInst) /* UL Data ReTransmisson */ isUlGrantPending = true; isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, TRUE, (SchUlHqProcCb**) &(node->node)); +#ifdef NR_DRX + if(isUlGrantScheduled) + { + schDrxStopUlHqRetxTmr(cell, &cell->ueCb[ueId-1], ((SchUlHqProcCb**) &(node->node))); + } +#endif cmLListDelFrm(&cell->ueCb[ueId-1].ulRetxHqList, node); } else diff --git a/src/du_app/du_f1ap_msg_hdl.c b/src/du_app/du_f1ap_msg_hdl.c index 3ffd24281..e96ebb509 100644 --- a/src/du_app/du_f1ap_msg_hdl.c +++ b/src/du_app/du_f1ap_msg_hdl.c @@ -13554,8 +13554,9 @@ uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg) UEContextSetupRequest_t *ueSetReq = NULL; DRBs_ToBeSetup_List_t *drbCfg = NULL; CUtoDURRCInformation_t *rrcInfo = NULL; +#ifdef NR_DRX DRXCycle_t *drxCycle; - +#endif ret = ROK; ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest; diff --git a/src/du_app/du_mgr_main.c b/src/du_app/du_mgr_main.c index 21312b5b8..d4783923d 100644 --- a/src/du_app/du_mgr_main.c +++ b/src/du_app/du_mgr_main.c @@ -548,7 +548,7 @@ uint8_t commonInit() DU_LOG("\nERROR --> DU_APP : System Task creation for DU APP failed"); return RFAILED; } - ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 16, 0); + //ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 16, 0); /* system task for EGTP */ if(ODU_CREATE_TASK(PRIOR0, &egtp_stsk) != ROK) @@ -556,7 +556,7 @@ uint8_t commonInit() DU_LOG("\nERROR --> DU_APP : System Task creation for EGTP failed"); return RFAILED; } - ODU_SET_THREAD_AFFINITY(&egtp_stsk, SS_AFFINITY_MODE_EXCL, 27, 0); + //ODU_SET_THREAD_AFFINITY(&egtp_stsk, SS_AFFINITY_MODE_EXCL, 27, 0); /* system task for RLC_DL and MAC */ if(ODU_CREATE_TASK(PRIOR0, &rlc_mac_cl_stsk) != ROK) @@ -566,7 +566,7 @@ uint8_t commonInit() } pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); - ODU_SET_THREAD_AFFINITY(&rlc_mac_cl_stsk, SS_AFFINITY_MODE_EXCL, 18, 0); + //ODU_SET_THREAD_AFFINITY(&rlc_mac_cl_stsk, SS_AFFINITY_MODE_EXCL, 18, 0); /* system task for RLC UL */ if(ODU_CREATE_TASK(PRIOR1, &rlc_ul_stsk) != ROK) @@ -574,7 +574,7 @@ uint8_t commonInit() DU_LOG("\nERROR --> DU_APP : System Task creation for RLC UL failed"); return RFAILED; } - ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 22, 0); + //ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 22, 0); /* system task for SCTP receiver thread */ if(ODU_CREATE_TASK(PRIOR0, &sctp_stsk) != ROK) @@ -582,7 +582,7 @@ uint8_t commonInit() DU_LOG("\nERROR --> DU_APP : System Task creation for SCTP failed"); return RFAILED; } - ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 25, 0); + //ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 25, 0); /* system task for lower-mac receiver thread */ if(ODU_CREATE_TASK(PRIOR0, &lwr_mac_stsk) != ROK) @@ -590,7 +590,7 @@ uint8_t commonInit() DU_LOG("\nERROR --> DU_APP : System Task creation for Lower MAC failed"); return RFAILED; } - ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 21, 0); + //ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 21, 0); #ifndef INTEL_WLS_MEM /* system task for phy stub's slot indication generator thread */ -- 2.16.6