D2dBinder.h Source File¶

Simu5G: D2dBinder.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 _D2DBINDER_H_
#define _D2DBINDER_H_
 
#include <map>
#include <set>
 
#include <inet/common/ModuleRefByPar.h>
 
#include "simu5g/common/LteCommon.h"
#include "simu5g/common/binder/Binder.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
class PhyBase;
class D2dBinder : public cSimpleModule, public cListener
{
  private:
    // reference to the core Binder, used for node and serving-cell lookups
    inet::ModuleRefByPar<Binder> binder_;
 
    // determines if two D2D-capable UEs are communicating in D2D mode or Infrastructure Mode
    std::map<MacNodeId, std::map<MacNodeId, LteD2DMode>> d2dPeeringMap_;
 
    // set of D2D one-to-many (multicast) transmitters
    std::set<MacNodeId> multicastTransmitterSet_;
 
    // The DRB ids in use within each sidelink node pair -- a UE and a peer UE, or a UE
    // and a multicast group -- pooled network-wide, since a sidelink bearer's ends are
    // UEs whose serving base stations may differ and change (a base station pools the
    // pairs it is itself a party to, see ConnectionControlEnb::assignDrbId())
    std::map<std::pair<MacNodeId, MacNodeId>, std::set<DrbId>> sidelinkDrbIds_;
 
  public:
    /*
     * The flow that established each multicast bearer, kept so that a node joining the group
     * later can still be given its RX leg (see ConnectionControlEnbD2D::multicastGroupJoined()).
     * The sender's base station provisions the members that exist when the sender starts,
     * which is all of them only if the node population is static; with nodes created
     * during the simulation the joiner would otherwise receive PDUs for a connection its
     * stack knows nothing about.
     *
     * Keyed by (multicast group id, sender id): the RX side of a bearer is keyed by its
     * sender (see FlowId::rxDrbKey, and MacCid(senderId, lcid) in
     * BearerManagement::createIncomingConnection), so a group served by several senders --
     * at once, or one after another as vehicles come and go -- needs one remembered flow per
     * sender. Each entry is dropped when its sender leaves, see receiveSignal().
     */
    struct MulticastFlow {
        FlowId flow;
        BearerRequest req;
        bool withPdcp = false;
 
        friend std::ostream& operator<<(std::ostream& os, const MulticastFlow& e)
        {
            os << "flow=[" << e.flow << "] req=[" << e.req << "] withPdcp=" << e.withPdcp;
            return os;
        }
    };
 
  private:
    std::map<std::pair<MacNodeId, MacNodeId>, MulticastFlow> multicastFlows_;
 
    // D2D-capable UE PHYs by node id, registered at init (see registerD2dPhy)
    std::map<MacNodeId, opp_component_ptr<PhyBase>> d2dPhys_;
 
  protected:
    void initialize() override;
    void handleMessage(cMessage *msg) override {}
 
    // compute the initial D2D mode for the given transmitter/receiver UE pair
    virtual LteD2DMode computeD2DCapability(MacNodeId src, MacNodeId dst);
    void receiveSignal(cComponent *source, simsignal_t signalID, long nodeId, cObject *details) override;
 
  public:
    virtual void registerD2dPhy(MacNodeId nodeId, PhyBase *phy);
    virtual PhyBase *getD2dPhy(MacNodeId nodeId);
    virtual bool checkD2DCapability(MacNodeId src, MacNodeId dst);
    virtual bool getD2DCapability(MacNodeId src, MacNodeId dst);
    virtual LteD2DMode getD2DMode(MacNodeId src, MacNodeId dst);
    const std::map<MacNodeId, std::map<MacNodeId, LteD2DMode>>& getD2DPeeringModeMap() const { return d2dPeeringMap_; }
    virtual void setD2DMode(MacNodeId src, MacNodeId dst, LteD2DMode mode);
 
    // add one D2D one-to-many (multicast) transmitter
    virtual void addD2DMulticastTransmitter(MacNodeId nodeId);
    // get the set of D2D one-to-many (multicast) transmitters
    virtual std::set<MacNodeId>& getD2DMulticastTransmitters();
 
    // The DRB id pool of a sidelink node pair (see sidelinkDrbIds_); the pair is ordered
    virtual std::set<DrbId>& sidelinkDrbIdPool(const std::pair<MacNodeId, MacNodeId>& pair);
    // Remember the flow that established a multicast bearer, unless the sender's flow
    // for the group is remembered already (see multicastFlows_)
    virtual void rememberMulticastFlow(MacNodeId groupId, MacNodeId senderId, const FlowId& flow, const BearerRequest& req, bool withPdcp);
    virtual const std::map<std::pair<MacNodeId, MacNodeId>, MulticastFlow>& getMulticastFlows() const { return multicastFlows_; }
};
 
} //namespace
 
#endif