Binder.h Source File¶

Simu5G: Binder.h Source File
Simu5G
//
//                  Simu5G
//
// Copyright (C) 2012-2021 Giovanni Nardini, Giovanni Stea, Antonio Virdis et al. (University of Pisa)
// Copyright (C) 2022-2026 Giovanni Nardini, Giovanni Stea et al. (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.
//
 
#ifndef _BINDER_H_
#define _BINDER_H_
 
#include <string>
 
#include <inet/networklayer/contract/ipv4/Ipv4Address.h>
#include <inet/networklayer/common/L3Address.h>
 
#include "simu5g/common/LteCommon.h"
#include "simu5g/common/blerCurves/PhyPisaData.h"
#include "simu5g/nodes/ExtCell.h"
#include "simu5g/stack/mac/LteMacBase.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
class UserPlaneNodeControl;
class UeStatsCollector;
 
 
struct NodeInfo {
    opp_component_ptr<cModule> moduleRef;
    opp_component_ptr<LteMacBase> macModule;
    bool isNr = false;    // the node's radio technology, as stated at registration. For a UE
                          // the id says the same thing (isNrUe()); for a base station this
                          // is the only record of it, since eNBs and gNBs share one id range.
};
class Binder : public cSimpleModule
{
  private:
 
    // name of the system (top-level) module
    std::string networkName_;
 
    // A node may be known under several addresses: a UE under those of its cellular
    // interface (several with IPv6, of either family on a dual-stack UE), a base station
    // under those of its X2 interfaces
    std::map<inet::L3Address, MacNodeId> ipAddressToMacNodeId_;
    std::map<inet::L3Address, MacNodeId> ipAddressToNrMacNodeId_;
 
    // Consolidated node information - replaces nodeIds_, macNodeIdToModuleName_, macNodeIdToModuleRef_, macNodeIdToModule_
    std::map<MacNodeId, NodeInfo> nodeInfoMap_;
 
    std::vector<MacNodeId> servingNode_;  // ueId -> servingEnbId
    std::vector<MacNodeId> secondaryNodeToMasterNodeOrSelf_;
 
    // stores the IP address of the MEC hosts in the simulation
    std::set<inet::L3Address> mecHostAddress_;
 
    // for GTP tunneling with MEC hosts involved
    // this map associates the L3 address of the Virt. Infrastructure of a MEC host to
    // the IP address of the corresponding UPF
    std::map<inet::L3Address, inet::L3Address> mecHostToUpfAddress_;
 
    // list of static external cells. Used for intercell interference evaluation
    std::map<GHz, ExtCellList> extCellList_;
 
    // list of static external cells. Used for intercell interference evaluation
    std::map<GHz, BackgroundSchedulerList> bgSchedulerList_;
 
    // list of all eNBs. Used for inter-cell interference evaluation
    std::vector<EnbInfo *> enbList_;
 
    // list of all UEs. Used for inter-cell interference evaluation
    std::vector<UeInfo *> ueList_;
 
    // list of all background traffic managers. Used for background UEs CQI computation
    std::vector<BgTrafficManagerInfo *> bgTrafficManagerList_;
 
    typedef std::map<unsigned int, std::map<unsigned int, double>> BgInterferenceMatrix;
 
    /*
     * Carrier Aggregation support
     */
    // total number of logical bands in the system. These bands
    unsigned int totalBands_ = 0;
    CarrierInfoMap componentCarriers_;
 
    // for each carrier, store the UEs that are able to use it
    typedef std::map<GHz, UeSet> CarrierUeMap;
    CarrierUeMap carrierUeMap_;
 
    // hack to link carrier freq to numerology index
    std::map<GHz, NumerologyIndex> carrierFreqToNumerologyIndex_;
    // max numerology index used by UEs
    std::vector<NumerologyIndex> ueMaxNumerologyIndex_;
    // set of numerologies used by each UE
    std::map<MacNodeId, std::set<NumerologyIndex>> ueNumerologyIndex_;
 
    /*
     * Uplink interference support
     */
    typedef std::map<GHz, std::vector<std::vector<std::vector<UeAllocationInfo>>>> UplinkTransmissionMap;
    // for each carrier frequency, for both previous and current TTIs, for each RB, stores the UE (nodeId and ref to the PHY module) that transmitted/are transmitting within that RB
    UplinkTransmissionMap ulTransmissionMap_;
    // TTI of the last update of the UL band status
    simtime_t lastUpdateUplinkTransmissionInfo_;
    // TTI of the last UL transmission (used for optimization purposes, see initAndResetUlTransmissionInfo() )
    simtime_t lastUplinkTransmission_;
 
    /*
     * X2 Support
     */
    typedef std::map<X2NodeId, std::list<int>> X2ListeningPortMap;
    X2ListeningPortMap x2ListeningPorts_;
 
    std::map<MacNodeId, std::map<MacNodeId, inet::L3Address>> x2PeerAddress_;
 
    /*
     * Multicast support
     */
    // register here the IDs of the multicast group where UEs participate
    typedef std::set<MacNodeId> MulticastGroupIdSet;
    std::map<MacNodeId, MulticastGroupIdSet> nodeGroupMemberships_;
 
    /*
     * Multicast destination ID support
     */
    // Counter for allocating new multicast destination IDs
    int16_t multicastDestIdCounter_ = MULTICAST_DEST_MIN_ID;
    // Mapping from IPv4 multicast addresses to allocated multicast destination IDs
    std::map<inet::Ipv4Address, MacNodeId> multicastAddrToDestId_;
    // Reverse mapping from multicast destination IDs to IPv4 addresses (optional, for debugging)
    std::map<MacNodeId, inet::Ipv4Address> multicastDestIdToAddr_;
 
  public:
    // The control-plane entry point of a user plane node (a UPF/PGW or a MEC host's UPF), as it
    // registered (see registerUserPlaneNode())
    struct UserPlaneNodeRegistration {
        UserPlaneNodeControl *module = nullptr;
        CoreNodeType type = UPF;
        std::string gateway;            // the core network gateway of a MEC host's UPF; empty otherwise
    };
 
  private:
    std::vector<UserPlaneNodeRegistration> userPlaneNodes_;       // in registration order
 
  protected:
    void initialize(int stages) override;
    int numInitStages() const override { return inet::NUM_INIT_STAGES; }
    void handleMessage(cMessage *msg) override {}
 
    void finish() override;
 
    // helpers
    virtual bool isValidNodeId(MacNodeId  nodeId) const;
 
  public:
    Binder() {}
 
    virtual unsigned int getTotalBands()
    {
        return totalBands_;
    }
 
    ~Binder() override
    {
        for (auto enb : enbList_)
            delete enb;
 
        for (auto bg : bgTrafficManagerList_)
            delete bg;
 
        for (auto ue : ueList_)
            delete ue;
    }
 
    virtual std::string& getNetworkName()
    {
        return networkName_;
    }
    virtual void registerCarrier(GHz carrierFrequency, unsigned int carrierNumBands, unsigned int numerologyIndex,
            bool useTdd = false, unsigned int tddNumSymbolsDl = 0, unsigned int tddNumSymbolsUl = 0);
    virtual void registerCarrierUe(GHz carrierFrequency, unsigned int numerologyIndex, MacNodeId ueId);
    virtual const UeSet& getCarrierUeSet(GHz carrierFrequency);
    virtual NumerologyIndex getUeMaxNumerologyIndex(MacNodeId ueId);
    virtual const std::set<NumerologyIndex> *getUeNumerologyIndex(MacNodeId ueId);
    virtual NumerologyIndex getNumerologyIndexFromCarrierFreq(GHz carrierFreq) { return carrierFreqToNumerologyIndex_[carrierFreq]; }
    virtual double getSlotDurationFromNumerologyIndex(NumerologyIndex numerologyIndex) { return pow(2.0, (-1) * (int)numerologyIndex) / 1000.0; }
    virtual SlotFormat computeSlotFormat(bool useTdd, unsigned int tddNumSymbolsDl, unsigned int tddNumSymbolsUl);
    virtual SlotFormat getSlotFormat(GHz carrierFrequency);
    virtual void registerNode(MacNodeId nodeId, cModule *nodeModule, RanNodeType type, bool isNr = false);
    static simsignal_t nodeUnregisteredSignal_;
    virtual void unregisterNode(MacNodeId id);
    virtual void registerUserPlaneNode(UserPlaneNodeControl *module, CoreNodeType type, const std::string& gateway);
    const std::vector<UserPlaneNodeRegistration>& getUserPlaneNodes() const { return userPlaneNodes_; }
    virtual void registerServingNode(MacNodeId enbId, MacNodeId ueId);
    virtual void unregisterServingNode(MacNodeId enbId, MacNodeId ueId);
    virtual MacNodeId getServingNode(MacNodeId ueId);
    virtual void registerMasterNode(MacNodeId masterId, MacNodeId slaveId);
    virtual bool nodeExists(MacNodeId nodeId) { return nodeInfoMap_.find(nodeId) != nodeInfoMap_.end(); }
    virtual cModule *getNodeModule(MacNodeId nodeId);
 
    /*
     * getNodeInfoMap returns information on all nodes in a map
     */
    virtual const std::map<MacNodeId, NodeInfo>& getNodeInfoMap() const { return nodeInfoMap_; }
 
    /*
     * getMacFromMacNodeId() returns the reference to the LteMacBase module
     * given the MacNodeId of a node
     *
     * @param id MacNodeId of the module
     * @return LteMacBase* of the module
     */
    virtual LteMacBase *getMacFromMacNodeId(MacNodeId id);
    virtual MacNodeId getServingNodeOrSelf(MacNodeId nodeId);
    //TODO add  MacNodeId ueId arg: In LTE DC, the roles (master/secondary) are per UE, not per bearer.
    virtual MacNodeId getMasterNodeOrSelf(MacNodeId secondaryEnbId);
    virtual MacNodeId getSecondaryNode(MacNodeId masterEnbId);
    virtual MacNodeId getMacNodeId(const inet::L3Address& address)
    {
        if (ipAddressToMacNodeId_.find(address) == ipAddressToMacNodeId_.end())
            return NODEID_NONE;
        MacNodeId nodeId = ipAddressToMacNodeId_[address];
 
        // if the UE is disconnected (its master node is 0), check the NR node Id
        if (getServingNodeOrSelf(nodeId) == NODEID_NONE)
            return getNrMacNodeId(address);
        return nodeId;
    }
    virtual MacNodeId getNrMacNodeId(const inet::L3Address& address)
    {
        if (ipAddressToNrMacNodeId_.find(address) == ipAddressToNrMacNodeId_.end())
            return NODEID_NONE;
        return ipAddressToNrMacNodeId_[address];
    }
    virtual MacNodeId getUeNodeId(MacNodeId ue, bool isNr);
    virtual bool isNrNodeB(MacNodeId nodeB);
    virtual inet::Ipv4Address getIPv4Address(MacNodeId nodeId)
    {
        for (const auto& kv : ipAddressToMacNodeId_) {
            if (kv.second == nodeId && kv.first.getType() == inet::L3Address::IPv4)
                return kv.first.toIpv4();
        }
        for (const auto& kv : ipAddressToNrMacNodeId_) {
            if (kv.second == nodeId && kv.first.getType() == inet::L3Address::IPv4)
                return kv.first.toIpv4();
        }
        return inet::Ipv4Address::UNSPECIFIED_ADDRESS;
    }
    virtual std::vector<inet::L3Address> getAddresses(MacNodeId nodeId)
    {
        std::vector<inet::L3Address> addresses;
        for (const auto& kv : isNrUe(nodeId) ? ipAddressToNrMacNodeId_ : ipAddressToMacNodeId_)
            if (kv.second == nodeId)
                addresses.push_back(kv.first);
        return addresses;
    }
    virtual X2NodeId getX2NodeId(const inet::L3Address& address)
    {
        return getMacNodeId(address);
    }
    virtual void setMacNodeId(const inet::L3Address& address, MacNodeId nodeId)
    {
        if (isNrUe(nodeId))
            ipAddressToNrMacNodeId_[address] = nodeId;
        else
            ipAddressToMacNodeId_[address] = nodeId;
    }
    virtual void unsetMacNodeId(const inet::L3Address& address, MacNodeId nodeId)
    {
        auto& addressToNodeId = isNrUe(nodeId) ? ipAddressToNrMacNodeId_ : ipAddressToMacNodeId_;
        auto it = addressToNodeId.find(address);
        if (it != addressToNodeId.end() && it->second == nodeId)
            addressToNodeId.erase(it);
    }
    virtual void setX2NodeId(const inet::L3Address& address, X2NodeId nodeId)
    {
        setMacNodeId(address, nodeId);
    }
 
    virtual inet::L3Address getX2PeerAddress(X2NodeId srcId, X2NodeId destId)
    {
        return x2PeerAddress_[srcId][destId];
    }
 
    virtual void setX2PeerAddress(X2NodeId srcId, X2NodeId destId, inet::L3Address interfAddr)
    {
        x2PeerAddress_[srcId].insert({destId, interfAddr});
    }
    virtual void registerMecHost(const inet::L3Address& mecHostAddress);
    virtual void registerMecHostUpfAddress(const inet::L3Address& mecHostAddress, const inet::L3Address& gtpAddress);
    virtual bool isMecHost(const inet::L3Address& mecHostAddress);
    virtual const inet::L3Address& getUpfFromMecHost(const inet::L3Address& mecHostAddress);
    virtual cModule *getModuleByMacNodeId(MacNodeId nodeId);
 
    /*
     * getDeployedUes() returns the affiliates
     * of a given eNodeB
     */
    virtual std::vector<MacNodeId> getDeployedUes(MacNodeId enbNodeId);
 
    PhyPisaData phyPisaData;
 
    virtual int getNodeCount() {
        return nodeInfoMap_.size();
    }
 
    virtual int addExtCell(ExtCell *extCell, GHz carrierFrequency)
    {
        if (extCellList_.find(carrierFrequency) == extCellList_.end())
            extCellList_[carrierFrequency] = ExtCellList();
 
        extCellList_[carrierFrequency].push_back(extCell);
        return extCellList_[carrierFrequency].size() - 1;
    }
 
    virtual ExtCellList getExtCellList(GHz carrierFrequency)
    {
        return extCellList_[carrierFrequency];
    }
 
    virtual int addBackgroundScheduler(BackgroundScheduler *bgScheduler, GHz carrierFrequency)
    {
        if (bgSchedulerList_.find(carrierFrequency) == bgSchedulerList_.end())
            bgSchedulerList_[carrierFrequency] = BackgroundSchedulerList();
 
        bgSchedulerList_[carrierFrequency].push_back(bgScheduler);
        return bgSchedulerList_[carrierFrequency].size() - 1;
    }
 
    virtual const BackgroundSchedulerList& getBackgroundSchedulerList(GHz carrierFrequency)
    {
        return bgSchedulerList_[carrierFrequency];
    }
 
    virtual void addEnbInfo(EnbInfo *info)
    {
        enbList_.push_back(info);
    }
 
    virtual const std::vector<EnbInfo *>& getEnbList()
    {
        return enbList_;
    }
 
    virtual void addUeInfo(UeInfo *info)
    {
        ueList_.push_back(info);
    }
 
    virtual const std::vector<UeInfo *>& getUeList()
    {
        return ueList_;
    }
 
    virtual void addBgTrafficManagerInfo(BgTrafficManagerInfo *info)
    {
        bgTrafficManagerList_.push_back(info);
    }
 
    virtual const std::vector<BgTrafficManagerInfo *>& getBgTrafficManagerList()
    {
        return bgTrafficManagerList_;
    }
 
    virtual Cqi meanCqi(std::vector<Cqi> bandCqi, MacNodeId id, Direction dir);
 
    virtual Cqi medianCqi(std::vector<Cqi> bandCqi, MacNodeId id, Direction dir);
 
    /*
     * Uplink interference support
     */
    virtual simtime_t getLastUpdateUlTransmissionInfo();
    virtual void initAndResetUlTransmissionInfo();
    virtual void storeUlTransmissionMap(GHz carrierFreq, Remote antenna, RbMap& rbMap, MacNodeId nodeId, MacCellId cellId, PhyBase *phy, Direction dir);
    virtual void storeUlTransmissionMap(GHz carrierFreq, Remote antenna, RbMap& rbMap, MacNodeId nodeId, MacCellId cellId, TrafficGeneratorBase *trafficGen, Direction dir);  // overloaded function for bgUes
    virtual const std::vector<std::vector<UeAllocationInfo>> *getUlTransmissionMap(GHz carrierFreq, UlTransmissionMapTTI t);
    /*
     * X2 Support
     */
    virtual void registerX2Port(X2NodeId nodeId, int port);
    virtual int getX2Port(X2NodeId nodeId);
 
    /*
     * Multicast Support
     */
    // add the group to the set of multicast group of nodeId
    virtual void joinMulticastGroup(MacNodeId nodeId, MacNodeId multicastDestId);
    // check if the node is enrolled in the group
    virtual bool isInMulticastGroup(MacNodeId nodeId, MacNodeId multicastDestId);
 
    /*
     * Multicast Destination ID Support
     */
    // Allocate an (MBMS-RNTI-like) multicast destination ID for a multicast IPv4 address
    virtual MacNodeId getOrAssignDestIdForMulticastAddress(inet::Ipv4Address multicastAddr);
    // Checks if a multicast destination ID was already assigned for a multicast IPv4 address
    virtual bool hasMulticastDestIdAssigned(inet::Ipv4Address multicastAddr) const {
        return multicastAddrToDestId_.find(multicastAddr) != multicastAddrToDestId_.end();
    }
    // Get existing multicast destination ID for a multicast address (returns NODEID_NONE if not found)
    virtual MacNodeId getDestIdForMulticastAddress(inet::Ipv4Address multicastAddr);
    // Get multicast address from destination ID
    virtual inet::Ipv4Address getAddressForMulticastDestId(MacNodeId multicastDestId);
 
    virtual void updateUeInfoCellId(MacNodeId nodeId, MacCellId cellId);
 
 
    /*
     * author Alessandro Noferi.
     *
     * UeStatsCollector management
     */
 
    /* this method adds the UeStatsCollector reference to the baseStationStatsCollector
     * structure.
     * @params:
     *  ue: MacNodeId of the ue
     *  ueCollector: reference to the collector
     *  cell: MacCellId of the target eNB
     */
    virtual void addUeCollectorToEnodeB(MacNodeId ue, UeStatsCollector *ueCollector, MacCellId cell);
 
    /* this method moves the UeStatsCollector reference between the eNB/gNB's baseStationStatsCollector
     * structure.
     * @params:
     *  ue: MacNodeId of the ue
     *  oldCell: MacCellId of the source eNB
     *  newCell: MacCellId of the target eNB
     */
    virtual void moveUeCollector(MacNodeId ue, MacCellId oldCell, MacCellId newCell);
 
    virtual bool isGNodeB(MacNodeId enbId);
 
    // Moved from LteCommon - getter functions that were taking Binder as first parameter
    virtual CellInfo *getCellInfoByNodeId(MacNodeId nodeId);
    virtual cModule *getPhyByNodeId(MacNodeId nodeId);
    virtual cModule *getMacByNodeId(MacNodeId nodeId);
    virtual cModule *getRrcByNodeId(MacNodeId nodeId);
    virtual cModule *getIp2NicByNodeId(MacNodeId nodeId);
};
 
} //namespace
 
#endif