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

// Copyright (c) 2024 Seoul National University (SNU)
// Copyright (c) 2024 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include "nr-mac-scheduler-ue-info-qos.h"
 
namespace ns3
{
class NrMacSchedulerUeInfoAi : public NrMacSchedulerUeInfoQos
{
  public:
    NrMacSchedulerUeInfoAi(float alpha, uint16_t rnti, BeamId beamId, const GetRbPerRbgFn& fn)
        : NrMacSchedulerUeInfoQos(alpha, rnti, beamId, fn)
    {
    }
 
    typedef std::unordered_map<uint8_t, double> Weights;
    typedef std::unordered_map<uint8_t, Weights> UeWeightsMap;
 
    struct LcObservation
    {
        uint16_t rnti;
        uint8_t lcId;
        uint8_t qci;
        uint8_t priority;
        uint16_t holDelay;
    };
 
    typedef std::function<void(const UeWeightsMap&)> UpdateAllUeWeightsFn;
    typedef Callback<void,
                     const std::vector<LcObservation>&,
                     bool,
                     float,
                     const std::string&,
                     const UpdateAllUeWeightsFn&>
        NotifyCb;
 
    void ResetDlSchedInfo() override
    {
        m_weightsDl.clear();
        NrMacSchedulerUeInfoQos::ResetDlSchedInfo();
    }
 
    void ResetUlSchedInfo() override
    {
        m_weightsUl.clear();
        NrMacSchedulerUeInfoQos::ResetUlSchedInfo();
    }
 
    std::vector<LcObservation> GetDlObservation();
 
    std::vector<LcObservation> GetUlObservation();
 
    void UpdateDlWeights(Weights& weights);
 
    void UpdateUlWeights(Weights& weights);
 
    float GetDlReward();
 
    float GetUlReward();
 
    static bool CompareUeWeightsDl(const NrMacSchedulerNs3::UePtrAndBufferReq& lue,
                                   const NrMacSchedulerNs3::UePtrAndBufferReq& rue)
    {
        double lAiMetric = CalculateDlWeight(lue);
        double rAiMetric = CalculateDlWeight(rue);
 
        return (lAiMetric > rAiMetric);
    }
 
    static double CalculateDlWeight(const NrMacSchedulerNs3::UePtrAndBufferReq& ue)
    {
        double weight = 0;
        auto uePtr = dynamic_cast<NrMacSchedulerUeInfoAi*>(ue.first.get());
 
        for (const auto& ueLcg : ue.first->m_dlLCG)
        {
            std::vector<uint8_t> ueActiveLCs = ueLcg.second->GetActiveLCIds();
 
            for (const auto lcId : ueActiveLCs)
            {
                auto it = uePtr->m_weightsDl.find(lcId);
 
                NS_ASSERT_MSG(it != uePtr->m_weightsDl.end(), "Weight not found for LC " << lcId);
                weight += it->second;
            }
        }
        return weight;
    }
 
    static bool CompareUeWeightsUl(const NrMacSchedulerNs3::UePtrAndBufferReq& lue,
                                   const NrMacSchedulerNs3::UePtrAndBufferReq& rue)
    {
        double lAiMetric = CalculateUlWeight(lue);
        double rAiMetric = CalculateUlWeight(rue);
 
        return (lAiMetric > rAiMetric);
    }
 
    static double CalculateUlWeight(const NrMacSchedulerNs3::UePtrAndBufferReq& ue)
    {
        double weight = 0;
        auto uePtr = dynamic_cast<NrMacSchedulerUeInfoAi*>(ue.first.get());
 
        for (const auto& ueLcg : ue.first->m_ulLCG)
        {
            std::vector<uint8_t> ueActiveLCs = ueLcg.second->GetActiveLCIds();
 
            for (const auto lcId : ueActiveLCs)
            {
                auto it = uePtr->m_weightsUl.find(lcId);
 
                NS_ASSERT_MSG(it != uePtr->m_weightsUl.end(), "Weight not found for LC " << lcId);
                weight += it->second;
            }
        }
        return weight;
    }
 
    Weights m_weightsDl; 
    Weights m_weightsUl; 
};
 
} // namespace ns3