nr-phy-mac-common.h

// Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
// Copyright (c) 2015, NYU WIRELESS, Tandon School of Engineering, New York University
// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef SRC_NR_MODEL_NR_PHY_MAC_COMMON_H
#define SRC_NR_MODEL_NR_PHY_MAC_COMMON_H
 
#include "nr-error-model.h"
#include "sfnsf.h"
 
#include "ns3/log.h"
#include "ns3/matrix-array.h"
#include "ns3/object.h"
#include "ns3/string.h"
 
#include <deque>
#include <list>
#include <map>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace ns3
{
 
struct GetFirst
{
    template <class First, class Second>
    First& operator()(std::pair<First, Second>& p)
    {
        return p.first;
    }
 
    template <class First, class Second>
    First& operator()(typename std::map<First, Second>::iterator& p)
    {
        return p.first;
    }
 
    template <class First, class Second>
    const First& operator()(const std::pair<First, Second>& p)
    {
        return p.first;
    }
 
    template <class First, class Second>
    const First& operator()(const typename std::map<First, Second>::iterator& p)
    {
        return p.first;
    }
};
 
struct GetSecond
{
    template <class First, class Second>
    Second& operator()(std::pair<First, Second>& p)
    {
        return p.second;
    }
 
    template <class First, class Second>
    Second& operator()(typename std::map<First, Second>::iterator& p)
    {
        return p.second;
    }
 
    template <class First, class Second>
    Second& operator()(typename std::unordered_map<First, Second>::iterator& p)
    {
        return p.second;
    }
 
    template <class First, class Second>
    const Second& operator()(const std::pair<First, Second>& p)
    {
        return p.second;
    }
 
    template <class First, class Second>
    const Second& operator()(const typename std::map<First, Second>::iterator& p)
    {
        return p.second;
    }
 
    template <class First, class Second>
    const Second& operator()(const typename std::unordered_map<First, Second>::iterator& p)
    {
        return p.second;
    }
};
 
enum CsiFeedbackFlag : uint8_t
{
    CQI_PDSCH_MIMO = 0x01, 
    CQI_CSI_RS = 0x02,     
    CQI_CSI_IM = 0x04,     
    CQI_PDSCH_SISO = 0x08  
};
 
struct DciInfoElementTdma
{
    enum DciFormat
    {
        DL = 0, 
        UL = 1  
    };
 
    enum VarTtiType
    {
        SRS = 0,  
        DATA = 1, 
        CTRL = 2, 
        MSG3 = 3, 
    };
 
    DciInfoElementTdma(uint8_t symStart,
                       uint8_t numSym,
                       DciFormat format,
                       VarTtiType type,
                       const std::vector<bool>& rbgBitmask)
        : m_format(format),
          m_symStart(symStart),
          m_numSym(numSym),
          m_type(type),
          m_rbgBitmask(rbgBitmask)
    {
    }
 
    DciInfoElementTdma(uint16_t rnti,
                       DciFormat format,
                       uint8_t symStart,
                       uint8_t numSym,
                       uint8_t mcs,
                       uint8_t rank,
                       Ptr<const ComplexMatrixArray> precMats,
                       uint32_t tbs,
                       uint8_t ndi,
                       uint8_t rv,
                       VarTtiType type,
                       uint8_t bwpIndex,
                       uint8_t tpc)
        : m_rnti(rnti),
          m_format(format),
          m_symStart(symStart),
          m_numSym(numSym),
          m_mcs(mcs),
          m_rank(rank),
          m_precMats(precMats),
          m_tbSize(tbs),
          m_ndi(ndi),
          m_rv(rv),
          m_type(type),
          m_bwpIndex(bwpIndex),
          m_tpc(tpc)
    {
    }
 
    DciInfoElementTdma(uint8_t symStart,
                       uint8_t numSym,
                       uint8_t ndi,
                       uint8_t rv,
                       const DciInfoElementTdma& o)
        : m_rnti(o.m_rnti),
          m_format(o.m_format),
          m_symStart(symStart),
          m_numSym(numSym),
          m_mcs(o.m_mcs),
          m_rank(o.m_rank),
          m_precMats(o.m_precMats),
          m_tbSize(o.m_tbSize),
          m_ndi(ndi),
          m_rv(rv),
          m_type(o.m_type),
          m_bwpIndex(o.m_bwpIndex),
          m_harqProcess(o.m_harqProcess),
          m_rbgBitmask(o.m_rbgBitmask),
          m_tpc(o.m_tpc)
    {
    }
 
    const uint16_t m_rnti{0};     
    const DciFormat m_format{DL}; 
    const uint8_t m_symStart{0};  
    const uint8_t m_numSym{0};    
    const uint8_t m_mcs{0};       
    const uint8_t m_rank{1};      
    Ptr<const ComplexMatrixArray> m_precMats{nullptr};
    const uint32_t m_tbSize{0};       
    const uint8_t m_ndi{0};           
    const uint8_t m_rv{0};            
    const VarTtiType m_type{SRS};     
    const uint8_t m_bwpIndex{0};      
    uint8_t m_harqProcess{0};         
    std::vector<bool> m_rbgBitmask{}; 
    const uint8_t m_tpc{0};           
};
 
struct RlcPduInfo
{
    RlcPduInfo() = default;
    RlcPduInfo(const RlcPduInfo& o) = default;
    ~RlcPduInfo() = default;
 
    RlcPduInfo(uint8_t lcid, uint32_t size)
        : m_lcid(lcid),
          m_size(size)
    {
    }
 
    uint8_t m_lcid{0};
    uint32_t m_size{0};
};
 
struct VarTtiAllocInfo
{
    VarTtiAllocInfo(const VarTtiAllocInfo& o) = default;
 
    VarTtiAllocInfo(const std::shared_ptr<DciInfoElementTdma>& dci)
        : m_dci(dci)
    {
    }
 
    bool m_isOmni{false};
    std::shared_ptr<DciInfoElementTdma> m_dci;
    std::vector<RlcPduInfo> m_rlcPduInfo;
 
    bool operator<(const VarTtiAllocInfo& o) const
    {
        NS_ASSERT(m_dci != nullptr);
        return (m_dci->m_symStart < o.m_dci->m_symStart);
    }
};
 
struct NrBuildRarListElement_s
{
    std::shared_ptr<DciInfoElementTdma>
        ulMsg3Dci;             
    uint8_t raPreambleId{255}; 
    uint32_t k2Delay{100}; 
};
 
struct SlotAllocInfo
{
    SlotAllocInfo(SfnSf sfn)
        : m_sfnSf(sfn)
    {
    }
 
    enum AllocationType
    {
        NONE = 0, 
        DL = 1,   
        UL = 2,   
        BOTH = 3  
    };
 
    void Merge(const SlotAllocInfo& other);
 
    bool ContainsDataAllocation() const;
 
    bool ContainsUlMsg3Allocation() const;
 
    bool ContainsDlCtrlAllocation() const;
 
    bool ContainsUlCtrlAllocation() const;
 
    SfnSf m_sfnSf{};                                     
    uint32_t m_numSymAlloc{0};                           
    std::deque<VarTtiAllocInfo> m_varTtiAllocInfo;       
    AllocationType m_type{NONE};                         
    std::vector<NrBuildRarListElement_s> m_buildRarList; 
    bool operator<(const SlotAllocInfo& rhs) const;
};
 
struct DlCqiInfo
{
    uint16_t m_rnti{0}; 
    // TODO: Rename to m_rank (m_ri is set directly to the rank).
    uint8_t m_ri{0}; 
 
    // TODO: use NrMacSchedulerUeInfo::CqiInfo
    enum DlCqiType
    {
        WB,
        SB
    } m_cqiType{WB}; 
 
    uint8_t m_wbCqi{0}; 
    size_t m_wbPmi{0};  
 
    std::vector<uint8_t> m_sbCqis; 
    std::vector<size_t> m_sbPmis;  
    uint8_t m_mcs{0};              
    Ptr<const ComplexMatrixArray> m_optPrecMat{}; 
};
 
struct PmCqiInfo
{
    uint8_t m_mcs{0};              
    uint8_t m_rank{0};             
    size_t m_wbPmi{0};             
    uint8_t m_wbCqi{0};            
    std::vector<uint8_t> m_sbCqis; 
    std::vector<size_t> m_sbPmis;  
    Ptr<const ComplexMatrixArray> m_optPrecMat{};  
    DlCqiInfo::DlCqiType m_cqiType{DlCqiInfo::WB}; 
    size_t m_tbSize{}; 
};
 
struct UlCqiInfo
{
    // std::vector <uint16_t> m_sinr;
    std::vector<double> m_sinr;
 
    enum UlCqiType
    {
        SRS,
        PUSCH,
        PUCCH_1,
        PUCCH_2,
        PRACH
    } m_type;
};
 
struct MacCeValue
{
    MacCeValue()
        : m_phr(0),
          m_crnti(0)
    {
    }
 
    uint8_t m_phr;
    uint8_t m_crnti;
    std::vector<uint8_t> m_bufferStatus;
};
 
struct MacCeElement
{
    MacCeElement()
        : m_rnti(0)
    {
    }
 
    uint16_t m_rnti;
 
    enum MacCeType
    {
        BSR,
        PHR,
        CRNTI
    } m_macCeType;
    struct MacCeValue m_macCeValue;
};
 
struct RlcListElement
{
    std::vector<struct RlcPduInfo> m_rlcPduElements;
};
 
struct UePhyPacketCountParameter
{
    uint64_t m_imsi;
    uint32_t m_noBytes;
    bool m_isTx; // Set to false if Rx and true if tx
    uint32_t m_subframeno;
};
 
struct GnbPhyPacketCountParameter
{
    uint64_t m_cellId;
    uint32_t m_noBytes;
    bool m_isTx; // Set to false if Rx and true if tx
    uint32_t m_subframeno;
};
 
struct ExpectedTb
{
    ExpectedTb(uint8_t ndi,
               uint32_t tbSize,
               uint8_t mcs,
               uint8_t rank,
               uint16_t rnti,
               const std::vector<int>& rbBitmap,
               uint8_t harqProcessId,
               uint8_t rv,
               bool isDownlink,
               uint8_t symStart,
               uint8_t numSym,
               const SfnSf& sfn)
        : m_ndi(ndi),
          m_tbSize(tbSize),
          m_mcs(mcs),
          m_rank(rank),
          m_rnti(rnti),
          m_rbBitmap(rbBitmap),
          m_harqProcessId(harqProcessId),
          m_rv(rv),
          m_isDownlink(isDownlink),
          m_symStart(symStart),
          m_numSym(numSym),
          m_sfn(sfn)
    {
    }
 
    ExpectedTb() = delete;
    ExpectedTb(const ExpectedTb& o) = default;
 
    uint8_t m_ndi{0};            
    uint32_t m_tbSize{0};        
    uint8_t m_mcs{0};            
    uint8_t m_rank{1};           
    uint16_t m_rnti{0};          
    std::vector<int> m_rbBitmap; 
    uint8_t m_harqProcessId{0};  
    uint8_t m_rv{0};             
    bool m_isDownlink{false};    
    uint8_t m_symStart{0};       
    uint8_t m_numSym{0};         
    SfnSf m_sfn;                 
};
 
struct TransportBlockInfo
{
    TransportBlockInfo(const ExpectedTb& expected)
        : m_expected(expected)
    {
    }
 
    TransportBlockInfo() = delete;
 
    void UpdatePerceivedSinr(const SpectrumValue& perceivedSinr);
 
    ExpectedTb m_expected;          
    bool m_isCorrupted{false};      
                                    //    Filled at the end of data rx/tx
    bool m_harqFeedbackSent{false}; 
    Ptr<NrErrorModelOutput> m_outputOfEM; 
    double m_sinrAvg{0.0};                
    double m_sinrMin{0.0}; 
};
 
struct RxPacketTraceParams
{
    RxPacketTraceParams(TransportBlockInfo tbInfo,
                        bool errorModelEnabled,
                        uint16_t rnti,
                        uint16_t cellId,
                        uint16_t bwpId,
                        uint8_t cqi)
        : m_cellId(cellId),
          m_rnti(rnti),
          m_frameNum(tbInfo.m_expected.m_sfn.GetFrame()),
          m_subframeNum(tbInfo.m_expected.m_sfn.GetSubframe()),
          m_slotNum(tbInfo.m_expected.m_sfn.GetSlot()),
          m_symStart(tbInfo.m_expected.m_symStart),
          m_numSym(tbInfo.m_expected.m_numSym),
          m_tbSize(tbInfo.m_expected.m_tbSize),
          m_mcs(tbInfo.m_expected.m_mcs),
          m_rank(tbInfo.m_expected.m_rank),
          m_rv(tbInfo.m_expected.m_rv),
          m_sinr(tbInfo.m_sinrAvg),
          m_sinrMin(tbInfo.m_sinrMin),
          m_tbler(errorModelEnabled ? tbInfo.m_outputOfEM->m_tbler : 0),
          m_corrupt(errorModelEnabled && tbInfo.m_isCorrupted),
          m_bwpId(bwpId),
          m_rbAssignedNum(static_cast<uint32_t>(tbInfo.m_expected.m_rbBitmap.size())),
          m_cqi(cqi){};
    uint64_t m_cellId{0};
    uint16_t m_rnti{0};
    uint32_t m_frameNum{std::numeric_limits<uint32_t>::max()};
    uint8_t m_subframeNum{std::numeric_limits<uint8_t>::max()};
    uint16_t m_slotNum{std::numeric_limits<uint16_t>::max()};
    uint8_t m_symStart{std::numeric_limits<uint8_t>::max()};
    uint8_t m_numSym{std::numeric_limits<uint8_t>::max()};
    uint32_t m_tbSize{0};
    uint8_t m_mcs{std::numeric_limits<uint8_t>::max()};
    uint8_t m_rank{std::numeric_limits<uint8_t>::max()};
    uint8_t m_rv{std::numeric_limits<uint8_t>::max()};
    double m_sinr{-1.0};
    double m_sinrMin{-1.0};
    double m_tbler{-1.0};
    bool m_corrupt{false};
    uint16_t m_bwpId{std::numeric_limits<uint16_t>::max()};
    uint32_t m_rbAssignedNum{std::numeric_limits<uint32_t>::max()};
    uint8_t m_cqi{std::numeric_limits<uint8_t>::max()};
};
 
struct HarqInfo
{
    virtual ~HarqInfo()
    {
    }
 
    uint16_t m_rnti{UINT16_MAX};        
    uint8_t m_harqProcessId{UINT8_MAX}; 
    uint8_t m_bwpIndex{UINT8_MAX};      
 
    virtual bool IsReceivedOk() const = 0;
};
 
struct DlHarqInfo : public HarqInfo
{
    enum HarqStatus
    {
        ACK,
        NACK
    } m_harqStatus{NACK}; 
 
    uint8_t m_numRetx; 
 
    bool IsReceivedOk() const override
    {
        return m_harqStatus == ACK;
    }
};
 
struct UlHarqInfo : public HarqInfo
{
    std::vector<uint16_t> m_ulReception;
 
    enum ReceptionStatus
    {
        Ok,
        NotOk,
        NotValid
    } m_receptionStatus;
 
    uint8_t m_tpc{UINT8_MAX};     
    uint8_t m_numRetx{UINT8_MAX}; 
 
    bool IsReceivedOk() const override
    {
        return m_receptionStatus == Ok;
    }
};
 
namespace nr
{
 
struct VendorSpecificValue : public SimpleRefCount<VendorSpecificValue>
{
    virtual ~VendorSpecificValue(){};
};
 
struct VendorSpecificListElement_s
{
    uint32_t m_type{UINT32_MAX};      
    uint32_t m_length{UINT32_MAX};    
    Ptr<VendorSpecificValue> m_value; 
};
 
struct LogicalChannelConfigListElement_s
{
    uint8_t m_logicalChannelIdentity{UINT8_MAX}; 
    uint8_t m_logicalChannelGroup{UINT8_MAX};    
 
    enum Direction_e
    {
        DIR_UL,
        DIR_DL,
        DIR_BOTH,
        NotValid
    } m_direction{NotValid}; 
 
    enum QosBearerType_e
    {
        QBT_NON_GBR,
        QBT_GBR,
        QBT_DGBR,
        NotValid_QosBearerType
    } m_qosBearerType{NotValid_QosBearerType}; 
 
    uint8_t m_qci{UINT8_MAX};                       
    uint64_t m_eRabMaximulBitrateUl{UINT64_MAX};    
    uint64_t m_eRabMaximulBitrateDl{UINT64_MAX};    
    uint64_t m_eRabGuaranteedBitrateUl{UINT64_MAX}; 
    uint64_t m_eRabGuaranteedBitrateDl{UINT64_MAX}; 
};
 
struct RachListElement_s
{
    uint16_t m_rnti{UINT16_MAX};          
    uint16_t m_estimatedSize{UINT16_MAX}; 
};
 
struct MacCeValue_u
{
    uint8_t m_phr{UINT8_MAX};            
    uint8_t m_crnti{UINT8_MAX};          
    std::vector<uint8_t> m_bufferStatus; 
};
 
struct MacCeListElement_s
{
    uint16_t m_rnti{UINT16_MAX}; 
 
    enum MacCeType_e
    {
        BSR,
        PHR,
        CRNTI,
        NotValid
    } m_macCeType{NotValid};          
    struct MacCeValue_u m_macCeValue; 
};
 
} // namespace nr
 
std::ostream& operator<<(std::ostream& os, const DciInfoElementTdma& item);
std::ostream& operator<<(std::ostream& os, const DciInfoElementTdma::DciFormat& item);
std::ostream& operator<<(std::ostream& os, const DlHarqInfo& item);
std::ostream& operator<<(std::ostream& os, const UlHarqInfo& item);
std::ostream& operator<<(std::ostream& os, const SfnSf& item);
std::ostream& operator<<(std::ostream& os, const SlotAllocInfo& item);
std::ostream& operator<<(std::ostream& os, const SlotAllocInfo::AllocationType& item);
} // namespace ns3
 
struct NrSchedulingCallbackInfo
{
    uint16_t m_frameNum{UINT16_MAX};  
    uint8_t m_subframeNum{UINT8_MAX}; 
    uint16_t m_slotNum{UINT16_MAX};   
    uint8_t m_symStart{UINT8_MAX};    
    uint8_t m_numSym{UINT8_MAX};      
    uint16_t m_rnti{UINT16_MAX};      
    uint8_t m_mcs{UINT8_MAX};         
    uint32_t m_tbSize{UINT32_MAX};    
    uint8_t m_bwpId{UINT8_MAX};       
    uint8_t m_ndi{UINT8_MAX};         
    uint8_t m_rv{UINT8_MAX};          
    uint8_t m_harqId{UINT8_MAX};      
};
 
#endif /* SRC_NR_MODEL_NR_PHY_MAC_COMMON_H_ */