nr-fh-control.h

// Copyright (c) 2023 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_FH_CONTROL_H
#define NR_FH_CONTROL_H
 
#include "nr-eesm-t1.h"
#include "nr-eesm-t2.h"
#include "nr-fh-phy-sap.h"
#include "nr-fh-sched-sap.h"
 
#include "ns3/object.h"
 
namespace ns3
{
 
class NrFhPhySapUser;
class NrFhPhySapProvider;
class NrFhSchedSapUser;
class NrFhSchedSapProvider;
 
class NrFhControl : public Object
{
  public:
    NrFhControl();
 
    ~NrFhControl() override;
 
    static TypeId GetTypeId();
 
    void SetNrFhPhySapUser(uint16_t bwpId, NrFhPhySapUser* s);
 
    NrFhPhySapProvider* GetNrFhPhySapProvider();
 
    void SetNrFhSchedSapUser(uint16_t bwpId, NrFhSchedSapUser* s);
 
    NrFhSchedSapProvider* GetNrFhSchedSapProvider();
 
    friend class MemberNrFhPhySapProvider<NrFhControl>;
    friend class MemberNrFhSchedSapProvider<NrFhControl>;
 
    enum FhControlMethod
    {
        Dropping,    
        Postponing,  
        OptimizeMcs, 
        OptimizeRBs, 
    };
 
    void SetFhControlMethod(FhControlMethod model);
 
    void SetCellFhCapacity(uint32_t capacity);
 
    void SetOverheadDyn(uint8_t overhead);
 
    void SetEnableModComp(bool v);
 
    void SetErrorModelType(std::string errorModelType);
 
    void SetPhysicalCellId(uint16_t physCellId);
 
    void SetFhNumerology(uint16_t bwpId, uint16_t num);
 
  private:
    FhControlMethod GetFhControlMethod() const;
 
    uint8_t DoGetFhControlMethod() const;
 
    uint16_t DoGetPhysicalCellId() const;
 
    void DoSetActiveUe(uint16_t bwpId, uint16_t rnti, uint32_t bytes);
 
    void DoUpdateActiveUesMap(
        uint16_t bwpId,
        const std::deque<VarTtiAllocInfo>& allocation,
        const std::unordered_map<uint16_t, std::shared_ptr<NrMacSchedulerUeInfo>>& ueMap);
 
    void DoSetActiveHarqUes(uint16_t bwpId, uint16_t rnti);
 
    bool DoGetDoesAllocationFit(uint16_t bwpId, uint32_t mcs, uint32_t nRegs, uint8_t dlRank);
 
    uint8_t DoGetMaxMcsAssignable(uint16_t bwpId, uint32_t reg, uint32_t rnti, uint8_t dlRank);
 
    uint32_t DoGetMaxRegAssignable(uint16_t bwpId, uint32_t mcs, uint32_t rnti, uint8_t dlRank);
 
    void DoUpdateTracesBasedOnDroppedData(uint16_t bwpId,
                                          uint32_t mcs,
                                          uint32_t nRbgs,
                                          uint32_t nSymb,
                                          uint8_t dlRank);
 
    void DoNotifyEndSlot(uint16_t bwpId, SfnSf currentSlot);
 
    uint64_t GetFhThr(uint16_t bwpId, uint32_t mcs, uint32_t nRegs, uint8_t dlRank) const;
 
    uint16_t GetNumberActiveBwps() const;
 
    uint16_t GetNumberActiveUes(uint16_t bwpId) const;
 
    uint8_t GetMaxMcs(uint8_t mcsTable, uint16_t modOrder) const;
 
    uint16_t m_physicalCellId; 
 
    // FH Control - PHY SAP
    std::map<uint16_t, NrFhPhySapUser*> m_fhPhySapUser; 
    NrFhPhySapProvider* m_fhPhySapProvider;             
 
    // FH Control - SCHEDULER SAP
    std::map<uint16_t, NrFhSchedSapUser*>
        m_fhSchedSapUser;                       
    NrFhSchedSapProvider* m_fhSchedSapProvider; 
 
    enum FhControlMethod m_fhControlMethod;
    uint32_t m_fhCapacity{
        1000}; 
    uint8_t m_overheadDyn{32};    
    uint8_t m_mcsTable{2};        
    std::string m_errorModelType; 
    bool m_enableModComp{
        true}; 
 
    std::unordered_map<uint16_t, uint16_t> m_numerologyPerBwp; 
    std::unordered_map<uint32_t, uint32_t>
        m_rntiQueueSize; 
    // std::unordered_map<uint16_t, uint16_t>
    std::unordered_map<uint16_t, std::set<uint16_t>>
        m_activeUesPerBwp; 
    // std::unordered_map<uint16_t, uint16_t>
    //     m_activeBwps; //!< Map of active BWPs - with UEs with new data (bwpId, number of UEs)
    std::unordered_map<uint16_t, std::set<uint16_t>>
        m_activeHarqUesPerBwp; 
    // std::unordered_map<uint16_t, uint16_t>
    //     m_activeHarqBwps; //!< Map of active BWPs - with UEs with active HARQ (bwpId, number of
    //     UEs)
 
    uint64_t m_allocThrPerCell{0}; 
    std::unordered_map<uint16_t, uint64_t>
        m_allocThrPerBwp; 
 
    std::unordered_map<uint16_t, uint64_t>
        m_reqFhDlThrTracedValuePerBwp; 
    std::unordered_map<uint16_t, uint32_t>
        m_rbsAirTracedValue; 
    std::unordered_map<uint16_t, SfnSf> m_waitingSlotPerBwp;
 
    // SfnSf, physicalCellId, bwpId, FH throughput
    TracedCallback<const SfnSf&, uint16_t, uint16_t, uint64_t>
        m_reqFhDlThrTrace; 
    // SfnSf, physicalCellId, bwpId, RBs used
    TracedCallback<const SfnSf&, uint16_t, uint16_t, uint32_t>
        m_rbsAirTrace; 
 
    NrEesmT1 nrEesmT1; 
    NrEesmT2 nrEesmT2; 
};
 
} // end namespace ns3
 
#endif // NR_FH_CONTROL_H