nr-mac-scheduler-ue-info-qos.h

// Copyright (c) 2022 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include "nr-mac-scheduler-ue-info-rr.h"
 
namespace ns3
{
class NrMacSchedulerUeInfoQos : public NrMacSchedulerUeInfo
{
  public:
    NrMacSchedulerUeInfoQos(float alpha, uint16_t rnti, BeamId beamId, const GetRbPerRbgFn& fn)
        : NrMacSchedulerUeInfo(rnti, beamId, fn),
          m_alpha(alpha)
    {
    }
 
    void ResetDlSchedInfo() override
    {
        m_lastAvgTputDl = m_avgTputDl;
        m_avgTputDl = 0.0;
        m_currTputDl = 0.0;
        m_potentialTputDl = 0.0;
        NrMacSchedulerUeInfo::ResetDlSchedInfo();
    }
 
    void ResetUlSchedInfo() override
    {
        m_lastAvgTputUl = m_avgTputUl;
        m_avgTputUl = 0.0;
        m_currTputUl = 0.0;
        m_potentialTputUl = 0.0;
        NrMacSchedulerUeInfo::ResetUlSchedInfo();
    }
 
    void ResetDlMetric() override
    {
        NrMacSchedulerUeInfo::ResetDlMetric();
        m_avgTputDl = m_lastAvgTputDl;
    }
 
    void ResetUlMetric() override
    {
        NrMacSchedulerUeInfo::ResetUlMetric();
        m_avgTputUl = m_lastAvgTputUl;
    }
 
    void UpdateDlQosMetric(const NrMacSchedulerNs3::FTResources& totAssigned, double timeWindow);
 
    void UpdateUlQosMetric(const NrMacSchedulerNs3::FTResources& totAssigned, double timeWindow);
 
    void CalculatePotentialTPutDl(const NrMacSchedulerNs3::FTResources& assignableInIteration);
 
    void CalculatePotentialTPutUl(const NrMacSchedulerNs3::FTResources& assignableInIteration);
 
    static bool CompareUeWeightsDl(const NrMacSchedulerNs3::UePtrAndBufferReq& lue,
                                   const NrMacSchedulerNs3::UePtrAndBufferReq& rue)
    {
        double lQoSMetric = CalculateDlWeight(lue);
        double rQoSMetric = CalculateDlWeight(rue);
 
        NS_ASSERT_MSG(lQoSMetric > 0, "Weight must be greater than zero");
        NS_ASSERT_MSG(rQoSMetric > 0, "Weight must be greater than zero");
 
        return (lQoSMetric > rQoSMetric);
    }
 
    static double CalculateDlWeight(const NrMacSchedulerNs3::UePtrAndBufferReq& ue)
    {
        double weight = 0;
        auto uePtr = dynamic_cast<NrMacSchedulerUeInfoQos*>(ue.first.get());
 
        for (const auto& ueLcg : ue.first->m_dlLCG)
        {
            std::vector<uint8_t> ueActiveLCs = ueLcg.second->GetActiveLCIds();
 
            for (const auto lcId : ueActiveLCs)
            {
                std::unique_ptr<NrMacSchedulerLC>& LCPtr = ueLcg.second->GetLC(lcId);
                double delayBudgetFactor = 1.0;
 
                if (LCPtr->m_resourceType == nr::LogicalChannelConfigListElement_s::QBT_DGBR)
                {
                    delayBudgetFactor =
                        CalculateDelayBudgetFactor(LCPtr->m_delayBudget.GetMilliSeconds(),
                                                   LCPtr->m_rlcTransmissionQueueHolDelay);
                }
                weight += (100 - LCPtr->m_priority) *
                          std::pow(uePtr->m_potentialTputDl, uePtr->m_alpha) /
                          std::max(1E-9, uePtr->m_avgTputDl) * delayBudgetFactor;
                NS_ASSERT_MSG(weight > 0, "Weight must be greater than zero");
            }
        }
        return weight;
    }
 
    static double CalculateDelayBudgetFactor(uint64_t pdb, uint16_t hol)
    {
        double denominator = hol >= pdb ? 0.1 : static_cast<double>(pdb) - static_cast<double>(hol);
        double delayBudgetFactor = static_cast<double>(pdb) / denominator;
 
        return delayBudgetFactor;
    }
 
    static bool CompareUeWeightsUl(const NrMacSchedulerNs3::UePtrAndBufferReq& lue,
                                   const NrMacSchedulerNs3::UePtrAndBufferReq& rue)
    {
        auto luePtr = dynamic_cast<NrMacSchedulerUeInfoQos*>(lue.first.get());
        auto ruePtr = dynamic_cast<NrMacSchedulerUeInfoQos*>(rue.first.get());
 
        double leftP = CalculateUlMinPriority(lue);
        double rightP = CalculateUlMinPriority(rue);
        NS_ABORT_IF(leftP == 0);
        NS_ABORT_IF(rightP == 0);
 
        double lQoSMetric = (100 - leftP) * std::pow(luePtr->m_potentialTputUl, luePtr->m_alpha) /
                            std::max(1E-9, luePtr->m_avgTputUl);
        double rQoSMetric = (100 - rightP) * std::pow(ruePtr->m_potentialTputUl, ruePtr->m_alpha) /
                            std::max(1E-9, ruePtr->m_avgTputUl);
 
        return (lQoSMetric > rQoSMetric);
    }
 
    static uint8_t CalculateDlMinPriority(const NrMacSchedulerNs3::UePtrAndBufferReq& ue)
    {
        uint8_t ueMinPriority = 100;
 
        for (const auto& ueLcg : ue.first->m_dlLCG)
        {
            std::vector<uint8_t> ueActiveLCs = ueLcg.second->GetActiveLCIds();
 
            for (const auto lcId : ueActiveLCs)
            {
                std::unique_ptr<NrMacSchedulerLC>& LCPtr = ueLcg.second->GetLC(lcId);
 
                if (ueMinPriority > LCPtr->m_priority)
                {
                    ueMinPriority = LCPtr->m_priority;
                }
 
                ue.first->PrintLcInfo(ue.first->m_rnti,
                                      ueLcg.first,
                                      lcId,
                                      LCPtr->m_qci,
                                      LCPtr->m_priority,
                                      ueMinPriority);
            }
        }
        return ueMinPriority;
    }
 
    static uint8_t CalculateUlMinPriority(const NrMacSchedulerNs3::UePtrAndBufferReq& ue)
    {
        uint8_t ueMinPriority = 100;
 
        for (const auto& ueLcg : ue.first->m_ulLCG)
        {
            std::vector<uint8_t> ueActiveLCs = ueLcg.second->GetActiveLCIds();
 
            for (const auto lcId : ueActiveLCs)
            {
                std::unique_ptr<NrMacSchedulerLC>& LCPtr = ueLcg.second->GetLC(lcId);
 
                if (ueMinPriority > LCPtr->m_priority)
                {
                    ueMinPriority = LCPtr->m_priority;
                }
 
                ue.first->PrintLcInfo(ue.first->m_rnti,
                                      ueLcg.first,
                                      lcId,
                                      LCPtr->m_qci,
                                      LCPtr->m_priority,
                                      ueMinPriority);
            }
        }
        return ueMinPriority;
    }
 
    double m_currTputDl{0.0};      
    double m_avgTputDl{0.0};       
    double m_lastAvgTputDl{0.0};   
    double m_potentialTputDl{0.0}; 
    float m_alpha{0.0};            
 
    double m_currTputUl{0.0};      
    double m_avgTputUl{0.0};       
    double m_lastAvgTputUl{0.0};   
    double m_potentialTputUl{0.0}; 
};
 
} // namespace ns3