nr-mac-scheduler-ns3.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include "nr-amc.h"
#include "nr-fh-sched-sap.h"
#include "nr-mac-harq-vector.h"
#include "nr-mac-scheduler-cqi-management.h"
#include "nr-mac-scheduler-lcg.h"
#include "nr-mac-scheduler-ue-info.h"
#include "nr-mac-scheduler.h"
#include "nr-phy-mac-common.h"
 
#include "ns3/traced-callback.h"
 
#include <functional>
#include <list>
#include <memory>
 
namespace ns3
{
 
class NrSchedGeneralTestCase;
class NrSchedOfdmaSymbolPerBeamTestCase;
class NrMacSchedulerHarqRr;
class NrMacSchedulerSrsDefault;
class NrMacSchedulerLcAlgorithm;
class NrFhSchedSapUser;
class NrFhSchedSapProvider;
 
class NrMacSchedulerNs3 : public NrMacScheduler
{
    friend class NrTestSchedulerAiCase;
    friend class NrSchedOfdmaSymbolPerBeamTestCase;
 
  public:
    static TypeId GetTypeId();
 
    NrMacSchedulerNs3();
 
    NrMacSchedulerNs3(const NrMacSchedulerNs3& other) = delete;
 
    ~NrMacSchedulerNs3() override;
 
    // FH Control SAPs
    void SetNrFhSchedSapProvider(NrFhSchedSapProvider* s) override;
    NrFhSchedSapUser* GetNrFhSchedSapUser() override;
 
    void InstallDlAmc(const Ptr<NrAmc>& dlAmc);
 
    void InstallUlAmc(const Ptr<NrAmc>& ulAmc);
 
    Ptr<const NrAmc> GetUlAmc() const;
 
    Ptr<const NrAmc> GetDlAmc() const;
 
    struct PointInFTPlane
    {
        PointInFTPlane(uint32_t rbg, uint8_t sym)
            : m_rbg(rbg),
              m_sym(sym)
        {
        }
 
        uint32_t m_rbg; 
        uint8_t m_sym;  
    };
 
    typedef PointInFTPlane
        FTResources; 
 
    void DoCschedCellConfigReq(
        const NrMacCschedSapProvider::CschedCellConfigReqParameters& params) override;
    void DoCschedUeConfigReq(
        const NrMacCschedSapProvider::CschedUeConfigReqParameters& params) override;
    void DoSchedDlRlcBufferReq(
        const NrMacSchedSapProvider::SchedDlRlcBufferReqParameters& params) override;
    void DoSchedUlMacCtrlInfoReq(
        const NrMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters& params) override;
    void DoSchedDlCqiInfoReq(
        const NrMacSchedSapProvider::SchedDlCqiInfoReqParameters& params) override;
    void DoSchedUlCqiInfoReq(
        const NrMacSchedSapProvider::SchedUlCqiInfoReqParameters& params) override;
    void DoCschedUeReleaseReq(
        const NrMacCschedSapProvider::CschedUeReleaseReqParameters& params) override;
    void DoCschedLcConfigReq(
        const NrMacCschedSapProvider::CschedLcConfigReqParameters& params) override;
    void DoCschedLcReleaseReq(
        const NrMacCschedSapProvider::CschedLcReleaseReqParameters& params) override;
    void DoSchedDlTriggerReq(
        const NrMacSchedSapProvider::SchedDlTriggerReqParameters& params) override;
    void DoSchedUlTriggerReq(
        const NrMacSchedSapProvider::SchedUlTriggerReqParameters& params) override;
    void DoSchedUlSrInfoReq(
        const NrMacSchedSapProvider::SchedUlSrInfoReqParameters& params) override;
    void DoSchedSetMcs(uint32_t mcs) override;
    void DoSchedDlRachInfoReq(
        const NrMacSchedSapProvider::SchedDlRachInfoReqParameters& params) override;
    uint8_t GetDlCtrlSyms() const override;
    uint8_t GetUlCtrlSyms() const override;
    bool IsMaxSrsReached() const override;
 
    int64_t AssignStreams(int64_t stream) override;
 
    // to save some typing
    using HarqVectorIterator = NrMacHarqVector::iterator;
    using HarqVectorIteratorList = std::vector<HarqVectorIterator>;
 
    typedef std::pair<UePtr, uint32_t> UePtrAndBufferReq;
    typedef std::unordered_map<BeamId, std::vector<UePtrAndBufferReq>, BeamIdHash> ActiveUeMap;
    typedef std::unordered_map<BeamId, uint32_t, BeamIdHash> BeamSymbolMap;
    typedef std::unordered_map<BeamId, HarqVectorIteratorList, BeamIdHash> ActiveHarqMap;
 
    void SetCqiTimerThreshold(const Time& v);
    Time GetCqiTimerThreshold() const;
 
    void SetFixedDlMcs(bool v);
    bool IsDlMcsFixed() const;
 
    void SetFixedUlMcs(bool v);
    bool IsUlMcsFixed() const;
 
    void SetStartMcsDl(uint8_t v);
    uint8_t GetStartMcsDl() const;
 
    void SetMaxDlMcs(int8_t v);
    int8_t GetMaxDlMcs() const;
 
    void SetLcSched(const TypeId& type);
 
    void SetStartMcsUl(uint8_t v);
    uint8_t GetStartMcsUl() const;
 
    void SetDlCtrlSyms(uint8_t v);
 
    void SetUlCtrlSyms(uint8_t v);
 
    void SetDlNotchedRbgMask(const std::vector<bool>& dlNotchedRbgsMask);
 
    std::vector<bool> GetDlNotchedRbgMask() const;
 
    void SetUlNotchedRbgMask(const std::vector<bool>& ulNotchedRbgsMask);
 
    std::vector<bool> GetUlNotchedRbgMask() const;
 
    void SetSrsCtrlSyms(uint8_t v);
 
    uint8_t GetSrsCtrlSyms() const;
 
    void SetSrsInUlSlots(bool v);
 
    bool IsSrsInUlSlots() const;
 
    void SetSrsInFSlots(bool v);
 
    bool IsSrsInFSlots() const;
    void EnableHarqReTx(bool enableFlag);
    bool IsHarqReTxEnable() const override;
 
    void SetRachUlGrantMcs(uint8_t v);
 
  protected:
    virtual std::shared_ptr<NrMacSchedulerUeInfo> CreateUeRepresentation(
        const NrMacCschedSapProvider::CschedUeConfigReqParameters& params) const = 0;
 
    virtual uint8_t GetTpc() const = 0;
 
    virtual uint8_t ScheduleDlHarq(NrMacSchedulerNs3::PointInFTPlane* startingPoint,
                                   uint8_t symAvail,
                                   const ActiveHarqMap& activeDlHarq,
                                   const std::unordered_map<uint16_t, UePtr>& ueMap,
                                   std::vector<DlHarqInfo>* dlHarqToRetransmit,
                                   const std::vector<DlHarqInfo>& dlHarqFeedback,
                                   SlotAllocInfo* slotAlloc) const;
    virtual uint8_t ScheduleUlHarq(NrMacSchedulerNs3::PointInFTPlane* startingPoint,
                                   uint8_t symAvail,
                                   const std::unordered_map<uint16_t, UePtr>& ueMap,
                                   std::vector<UlHarqInfo>* ulHarqToRetransmit,
                                   const std::vector<UlHarqInfo>& ulHarqFeedback,
                                   SlotAllocInfo* slotAlloc) const;
 
    virtual BeamSymbolMap AssignDLRBG(uint32_t symAvail, const ActiveUeMap& activeDl) const = 0;
 
    virtual BeamSymbolMap AssignULRBG(uint32_t symAvail, const ActiveUeMap& activeUl) const = 0;
 
    virtual std::shared_ptr<DciInfoElementTdma> CreateDlDci(
        PointInFTPlane* spoint,
        const std::shared_ptr<NrMacSchedulerUeInfo>& ueInfo,
        uint32_t maxSym) const = 0;
 
    virtual std::shared_ptr<DciInfoElementTdma> CreateUlDci(
        PointInFTPlane* spoint,
        const std::shared_ptr<NrMacSchedulerUeInfo>& ueInfo,
        uint32_t maxSym) const = 0;
 
    virtual void ChangeDlBeam(PointInFTPlane* spoint, uint32_t symOfBeam) const = 0;
 
    virtual void ChangeUlBeam(PointInFTPlane* spoint, uint32_t symOfBeam) const = 0;
 
    virtual void SortDlHarq(ActiveHarqMap* activeDlHarq) const;
 
    virtual void SortUlHarq(ActiveHarqMap* activeUlHarq) const;
 
    virtual LCGPtr CreateLCG(const nr::LogicalChannelConfigListElement_s& config) const;
 
    virtual LCPtr CreateLC(const nr::LogicalChannelConfigListElement_s& config) const;
 
  public:
    uint64_t GetNumRbPerRbg() const;
 
  protected:
    Ptr<NrAmc> m_dlAmc; 
    Ptr<NrAmc> m_ulAmc; 
    NrMacSchedulerUeInfo::McsCsiSource
        m_mcsCsiSource; 
 
    bool m_activeDlAi{false}; 
    bool m_activeUlAi{false}; 
 
  private:
    struct AllocElem
    {
        AllocElem() = delete;
        AllocElem(const AllocElem& o) = default;
 
        AllocElem(uint16_t rnti,
                  uint32_t tbs,
                  uint8_t symStart,
                  uint8_t numSym,
                  uint8_t mcs,
                  uint8_t rank,
                  const std::vector<bool>& rbgMask)
            : m_rnti(rnti),
              m_tbs(tbs),
              m_symStart(symStart),
              m_numSym(numSym),
              m_mcs(mcs),
              m_rank(rank),
              m_rbgMask(rbgMask)
        {
        }
 
        uint16_t m_rnti{0};          
        uint32_t m_tbs{0};           
        uint8_t m_symStart{0};       
        uint8_t m_numSym{0};         
        uint8_t m_mcs{0};            
        uint8_t m_rank{1};           
        std::vector<bool> m_rbgMask; 
    };
 
    struct SlotElem
    {
        SlotElem() = delete;
        SlotElem(const SlotElem& o) = default;
 
        SlotElem(uint8_t totUlSym)
            : m_totUlSym(totUlSym)
        {
        }
 
        uint8_t m_totUlSym;                     
        std::vector<AllocElem> m_ulAllocations; 
    };
 
    void BSRReceivedFromUe(const MacCeElement& bsr);
 
    template <typename T>
    std::vector<T> MergeHARQ(std::vector<T>* existingFeedbacks,
                             const std::vector<T>& inFeedbacks,
                             const std::string& mode) const;
 
    void ResetExpiredHARQ(uint16_t rnti, NrMacHarqVector* harq);
 
    template <typename T>
    void ProcessHARQFeedbacks(std::vector<T>* harqInfo,
                              const NrMacSchedulerUeInfo::GetHarqVectorFn& GetHarqVectorFn,
                              const std::string& direction) const;
 
    void ScheduleDl(const NrMacSchedSapProvider::SchedDlTriggerReqParameters& params,
                    const std::vector<DlHarqInfo>& dlHarqInfo);
 
    void ScheduleUl(const NrMacSchedSapProvider::SchedUlTriggerReqParameters& params,
                    const std::vector<UlHarqInfo>& ulHarqInfo);
 
    uint8_t AppendCtrlSym(uint8_t symStart,
                          uint8_t numSymToAllocate,
                          DciInfoElementTdma::DciFormat mode,
                          std::deque<VarTtiAllocInfo>* allocations) const;
    uint8_t PrependCtrlSym(uint8_t symStart,
                           uint8_t numSymToAllocate,
                           DciInfoElementTdma::DciFormat mode,
                           std::deque<VarTtiAllocInfo>* allocations) const;
 
    void ComputeActiveUe(ActiveUeMap* activeDlUe,
                         const NrMacSchedulerUeInfo::GetLCGFn& GetLCGFn,
                         const NrMacSchedulerUeInfo::GetHarqVectorFn& GetHarqVector,
                         const std::string& mode) const;
    void ComputeActiveHarq(ActiveHarqMap* activeDlHarq,
                           const std::vector<DlHarqInfo>& dlHarqFeedback) const;
    void ComputeActiveHarq(ActiveHarqMap* activeUlHarq,
                           const std::vector<UlHarqInfo>& ulHarqFeedback) const;
 
    uint8_t DoScheduleDlData(PointInFTPlane* spoint,
                             uint32_t symAvail,
                             const ActiveUeMap& activeDl,
                             SlotAllocInfo* slotAlloc) const;
    uint8_t DoScheduleUlData(PointInFTPlane* spoint,
                             uint32_t symAvail,
                             const ActiveUeMap& activeUl,
                             SlotAllocInfo* slotAlloc) const;
    uint8_t DoScheduleUlMsg3(PointInFTPlane* sPoint, uint8_t symAvail, SlotAllocInfo* slotAlloc);
    void DoScheduleUlSr(PointInFTPlane* spoint, const std::list<uint16_t>& rntiList) const;
    uint8_t DoScheduleDl(const std::vector<DlHarqInfo>& dlHarqFeedback,
                         const ActiveHarqMap& activeDlHarq,
                         ActiveUeMap* activeDlUe,
                         const SfnSf& dlSfnSf,
                         const SlotElem& ulAllocations,
                         SlotAllocInfo* allocInfo);
    uint8_t DoScheduleUl(const std::vector<UlHarqInfo>& ulHarqFeedback,
                         const SfnSf& ulSfn,
                         SlotAllocInfo* allocInfo,
                         LteNrTddSlotType type);
    uint8_t DoScheduleSrs(PointInFTPlane* spoint, SlotAllocInfo* allocInfo);
 
    static const unsigned m_macHdrSize = 0; 
    static const uint32_t m_subHdrSize = 4; 
    static const unsigned m_rlcHdrSize = 3; 
 
  protected:
    uint16_t GetBwpId() const;
 
    uint16_t GetCellId() const;
 
    uint16_t GetBandwidthInRbg() const;
 
    uint8_t GetFhControlMethod() const;
 
    bool DoesFhAllocationFit(uint16_t bwpId, uint32_t mcs, uint32_t nRegs, uint8_t dlRank) const;
 
    // FFR SAPs
    NrFhSchedSapUser* m_nrFhSchedSapUser{nullptr};         
    NrFhSchedSapProvider* m_nrFhSchedSapProvider{nullptr}; 
 
  private:
    void CallNrFhControlForMapUpdate(
        const std::deque<VarTtiAllocInfo>& allocation,
        const std::unordered_map<uint16_t, std::shared_ptr<NrMacSchedulerUeInfo>>& ueMap);
 
    std::unordered_map<uint16_t, std::shared_ptr<NrMacSchedulerUeInfo>>
        m_ueMap; 
 
    std::map<uint64_t, SlotElem> m_ulAllocationMap;
 
    bool m_fixedMcsDl{false};  
    bool m_fixedMcsUl{false};  
    uint8_t m_startMcsDl{0};   
    uint8_t m_startMcsUl{0};   
    int8_t m_maxDlMcs{0};      
    Time m_cqiTimersThreshold; 
 
    uint8_t m_rachUlGrantMcs{0}; 
    uint8_t m_ulRachBwpIndex{
        0}; 
 
    NrMacSchedulerCQIManagement m_cqiManagement; 
 
    std::vector<DlHarqInfo>
        m_dlHarqToRetransmit; 
    std::vector<UlHarqInfo>
        m_ulHarqToRetransmit; 
 
    std::list<uint16_t> m_srList; 
 
    std::vector<struct nr::RachListElement_s> m_rachList; 
 
    uint16_t m_bandwidth{0};         
    uint8_t m_dlCtrlSymbols{0};      
    uint8_t m_ulCtrlSymbols{0};      
    uint8_t m_srsCtrlSymbols{0};     
    bool m_enableSrsInUlSlots{true}; 
    bool m_enableSrsInFSlots{true};  
 
    std::vector<bool> m_dlNotchedRbgsMask; 
    std::vector<bool> m_ulNotchedRbgsMask; 
 
    std::unique_ptr<NrMacSchedulerHarqRr> m_schedHarq; 
 
    Ptr<NrMacSchedulerSrsDefault> m_schedulerSrs; 
    Ptr<NrMacSchedulerLcAlgorithm>
        m_schedLc;        
    TypeId m_schedLcType; 
 
    uint32_t m_srsSlotCounter{0}; 
 
    friend NrSchedGeneralTestCase;
 
    bool m_enableHarqReTx{true}; 
 
    TracedCallback<uint16_t, uint16_t, const std::shared_ptr<NrMacSchedulerUeInfo>&>
        m_csiFeedbackReceived; 
};
 
} // namespace ns3