LteTypes.h Source File¶

Simu5G: LteTypes.h Source File
Simu5G
//
//                  Simu5G
//
// Authors: Giovanni Nardini, Giovanni Stea, Antonio Virdis (University of Pisa)
//
// This file is part of a software released under the license included in file
// "license.pdf". Please read LICENSE and README files before using it.
// The above files and the present reference are part of the software itself,
// and cannot be removed from it.
//
 
//
// This file contains fundamental LTE type definitions that are used both
// in MSG files (via cplusplus {{ #include }}) and in C++ code.
//
 
#ifndef _LTE_LTETYPES_H_
#define _LTE_LTETYPES_H_
 
#include <map>
#include <ostream>
#include <string>
 
#include <omnetpp.h>
#include <inet/common/Units.h>
 
#include "simu5g/common/LteCommonEnum_m.h"
 
using namespace omnetpp;
 
namespace simu5g {
#define SIMU5G_STRONG_TYPEDEF(TypeName, UnderlyingType) \
    enum class TypeName : UnderlyingType {}; \
    inline UnderlyingType num(TypeName id) { return static_cast<UnderlyingType>(id); } \
    inline std::ostream& operator<<(std::ostream& os, TypeName id) { os << +static_cast<UnderlyingType>(id); return os; } /* unary + : a uint8_t id is a number, not a character */ \
    inline void doParsimPacking(omnetpp::cCommBuffer *buffer, TypeName d) { buffer->pack(num(d)); } \
    inline void doParsimUnpacking(omnetpp::cCommBuffer *buffer, TypeName& d) { UnderlyingType tmp; buffer->unpack(tmp); d = TypeName(tmp); }
SIMU5G_STRONG_TYPEDEF(MacNodeId, unsigned short)
 
constexpr MacNodeId NODEID_NONE  = MacNodeId(0);
constexpr unsigned short ENB_MIN_ID   = 1;
constexpr unsigned short ENB_MAX_ID   = 1023;
constexpr unsigned short BGUE_ID      = 1024;
constexpr unsigned short UE_MIN_ID    = 1025;
constexpr unsigned short NR_UE_MIN_ID = 2049;
constexpr unsigned short BGUE_MIN_ID  = 4097;
constexpr unsigned short UE_MAX_ID    = 32767;
constexpr unsigned short MULTICAST_DEST_MIN_ID = 32768;
 
typedef MacNodeId MacCellId;
typedef MacNodeId X2NodeId;
SIMU5G_STRONG_TYPEDEF(LogicalCid, unsigned short)
SIMU5G_STRONG_TYPEDEF(DrbId, unsigned short)
SIMU5G_STRONG_TYPEDEF(Qfi, uint8_t)
// "no QFI": out of the 6-bit QFI value range (TS 38.331: 0..63), because 0 is a real
// QFI -- the default QoS flow's -- and a sentinel that collides with it cannot be told
// apart from a packet classified onto the default flow
constexpr Qfi QFI_NONE = Qfi(255);
SIMU5G_STRONG_TYPEDEF(Teid, uint32_t)
// "no tunnel": TEIDs are handed out from 1 (see UserPlaneNodeControl::allocateTeid() and ConnectionControlEnb::allocateTeid())
constexpr Teid TEID_NONE = Teid(0);
SIMU5G_STRONG_TYPEDEF(SessionId, uint8_t)
SIMU5G_STRONG_TYPEDEF(Lcg, uint8_t)
// LTE has 4 LCGs (TS 36.321), NR allows up to 8 (TS 38.321); the LCG schedulers serve
// this many, in increasing-index priority order (lower LCG index is served first)
constexpr unsigned short NUM_LCGS = 4;
 
constexpr LogicalCid LCID_NONE = LogicalCid(65535);
constexpr DrbId DRBID_NONE = DrbId(65535);
constexpr unsigned short MAX_DRB_ID = 32;
// TODO add LONG/TRUNCATED BSR
// TODO FIXME these conflict with DRB LCIDs (1..), and also 0 is reserved for CCCH (common control channel)
constexpr LogicalCid SHORT_BSR = LogicalCid(0); // should be 62 (NR)
constexpr LogicalCid D2D_SHORT_BSR = LogicalCid(1); // Simu5G-specific
constexpr LogicalCid D2D_MULTI_SHORT_BSR = LogicalCid(2); // Simu5G-specific
constexpr unsigned short BSR_UL_LCID_BASE = 64;
inline LogicalCid bsrLcidForLcg(Lcg lcg) { return LogicalCid(BSR_UL_LCID_BASE + num(lcg)); }
inline bool isUlBsrLcid(LogicalCid lcid) { return num(lcid) >= BSR_UL_LCID_BASE && num(lcid) < BSR_UL_LCID_BASE + NUM_LCGS; }
inline Lcg lcgFromBsrLcid(LogicalCid lcid) { ASSERT(isUlBsrLcid(lcid)); return Lcg(num(lcid) - BSR_UL_LCID_BASE); }
// MacCid is now a class with separate fields instead of a packed integer
typedef unsigned short Rank;
typedef unsigned short Cqi;
 
typedef unsigned short Tbs;
typedef unsigned short Band;
typedef std::map<Remote, std::map<Band, unsigned int>> RbMap;
class MacCid
{
private:
    MacNodeId nodeId_;
    LogicalCid lcid_;
 
public:
    // Default constructor
    MacCid() : nodeId_(NODEID_NONE), lcid_(LCID_NONE) {}
 
    // Constructor
    MacCid(MacNodeId nodeId, LogicalCid lcid) : nodeId_(nodeId), lcid_(lcid) {}
 
    // Getters
    MacNodeId getNodeId() const { return nodeId_; }
    LogicalCid getLcid() const { return lcid_; }
    unsigned int asPackedInt() const { return (num(nodeId_) << 16) | num(lcid_); }
 
    // Check if this is an empty/invalid MacCid (default constructed)
    bool isEmpty() const { return nodeId_ == NODEID_NONE && lcid_ == LCID_NONE; }
 
    // String representation
    std::string str() const { return "MacCid(nodeId=" + std::to_string(num(nodeId_)) + ", lcid=" + std::to_string(num(lcid_)) + ")"; }
 
    // Comparison operators for std::map compatibility
    bool operator<(const MacCid& other) const { return asPackedInt() < other.asPackedInt(); }
    bool operator==(const MacCid& other) const  { return nodeId_ == other.nodeId_ && lcid_ == other.lcid_; }
    bool operator!=(const MacCid& other) const { return nodeId_ != other.nodeId_ || lcid_ != other.lcid_; }
 
    // Stream output operator
    friend std::ostream& operator<<(std::ostream& os, const MacCid& cid) { return os << cid.str(); }
};
class DrbKey
{
private:
    MacNodeId nodeId_;
    DrbId drbId_;
 
public:
    // Default constructor
    DrbKey() : nodeId_(NODEID_NONE), drbId_(DRBID_NONE) {}
 
    // Constructor
    DrbKey(MacNodeId nodeId, DrbId drbId) : nodeId_(nodeId), drbId_(drbId) {}
 
    // Getters
    MacNodeId getNodeId() const { return nodeId_; }
    DrbId getDrbId() const { return drbId_; }
    unsigned int asPackedInt() const { return (num(nodeId_) << 16) | num(drbId_); }
 
    // Check if this is an empty/invalid DrbKey (default constructed)
    bool isEmpty() const { return nodeId_ == NODEID_NONE && drbId_ == DRBID_NONE; }
 
    // String representation
    std::string str() const { return "DrbKey(nodeId=" + std::to_string(num(nodeId_)) + ", drbId=" + std::to_string(num(drbId_)) + ")"; }
 
    // Comparison operators for std::map compatibility
    bool operator<(const DrbKey& other) const { return asPackedInt() < other.asPackedInt(); }
    bool operator==(const DrbKey& other) const  { return nodeId_ == other.nodeId_ && drbId_ == other.drbId_; }
    bool operator!=(const DrbKey& other) const { return nodeId_ != other.nodeId_ || drbId_ != other.drbId_; }
 
    // Stream output operator
    friend std::ostream& operator<<(std::ostream& os, const DrbKey& id) { return os << id.str(); }
};
 
} // namespace simu5g
 
#endif