LteMacEnb.h Source File¶

Simu5G: LteMacEnb.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 _LTE_LTEMACENB_H_
#define _LTE_LTEMACENB_H_
 
#include <inet/common/ModuleRefByPar.h>
 
#include "simu5g/common/cellInfo/CellInfo.h"
#include "simu5g/stack/mac/LteMacBase.h"
#include "simu5g/stack/mac/amc/LteAmc.h"
#include "simu5g/common/LteCommon.h"
#include "simu5g/background/trafficGenerator/IBackgroundTrafficManager.h"
#include "simu5g/stack/mac/DrbQosProfile.h"
#include "simu5g/stack/mac/UlBacklogRegistry.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
class MacBsr;
class LteAmc;
class LteSchedulerEnbDl;
class LteSchedulerEnbUl;
class ConflictGraph;
class LteHarqProcessRx;
 
class LteMacEnb : public LteMacBase
{
  protected:
    inet::ModuleRefByPar<CellInfo> cellInfo_;
    LteAmc *amc_ = nullptr;
    std::map<GHz, LteMacScheduleList> *scheduleListDl_ = nullptr;
 
    // For NR-SO DL cids: number of RLC PDUs requested this TTI (>1 = multiplexed into
    // one MAC PDU). The MAC PDU is built only once all of them have arrived from RLC.
    std::map<MacCid, unsigned int> soExpectedSdus_;
 
    int eNodeBCount;
    std::map<GHz, IBackgroundTrafficManager *> bgTrafficManager_;
 
    /*******************************************************************************************/
    int numPreambles_ = 64;
    std::map<int, std::vector<inet::Packet *>> pendingRacRequests_;
    UlBacklogRegistry ulBacklog_;
    LteSchedulerEnbDl *enbSchedulerDl_ = nullptr;
    LteSchedulerEnbUl *enbSchedulerUl_ = nullptr;
    std::map<GHz, std::map<Direction, int>> needRtx_;
    std::map<DrbKey, DrbQosProfile> drbQosMap_;
    void initialize(int stage) override;
    void handleMessage(cMessage *msg) override;
    virtual void sendGrants(std::map<GHz, LteMacScheduleList> *scheduleList);
    typedef std::map<std::pair<MacNodeId, Direction>, std::map<Codeword, unsigned int>> PerUeGrantBlocks;
    virtual PerUeGrantBlocks foldScheduleEntries(const LteMacScheduleList& entries) const;
    struct GrantBlocks { unsigned int totalBlocks = 0; unsigned int codewords = 0; };
    virtual GrantBlocks grantBlocksOf(MacNodeId nodeId, const std::map<Codeword, unsigned int>& cwBlocks) const;
    virtual Direction grantDirection(LogicalCid lcid) const { return directionFromBsrLcid(lcid, UL); }
    virtual inet::b grantChunkLength() const { return inet::B(1); }
    void macPduMake(MacCid cid) override;
    void macPduUnmake(cPacket *pkt) override;
    virtual void macSduRequest();
    virtual void bufferizeBsr(const MacBsr *bsr, const UserControlInfo *lteInfo);
    bool bufferizePacket(cPacket *pkt) override;
    void handleUpperMessage(cPacket *pkt) override;
    void handleSelfMessage() override;
    void macHandleFeedbackPkt(cPacket *pkt) override;
 
    /*
     * Buffers incoming RAC requests for preamble collision detection.
     */
    void macHandleRac(cPacket *pkt) override;
 
    /*
     * Resolves buffered RAC requests: detects preamble collisions and sends
     * success/failure responses. Called at the start of each TTI.
     */
    virtual void resolveRacCollisions();
 
    /*
     * Update UserTxParam stored in every lteMacPdu when an RTX changes this information.
     */
    void updateUserTxParam(cPacket *pkt) override;
    virtual void flushHarqBuffers();
 
  public:
 
    LteMacEnb();
    ~LteMacEnb() override;
    LteMacBuffer *getBsrVirtualBuffer(MacCid cid) { return ulBacklog_.mirror(cid); }
    std::vector<MacCid> getActiveBsrVirtualBufferCids() { return ulBacklog_.keys(); }
    std::vector<LteMacBuffer *> getUlBacklogMirrors(MacNodeId nodeId) const { return ulBacklog_.ulMirrorsOf(nodeId); }
    virtual void clearBsrBuffers(MacNodeId ueId);
    void deleteQueues(MacNodeId nodeId) override;
    virtual LteAmc *getAmc()
    {
        return amc_;
    }
    virtual CellInfo *getCellInfo();
    virtual IBackgroundTrafficManager *getBackgroundTrafficManager(GHz carrierFrequency)
    {
        if (bgTrafficManager_.find(carrierFrequency) == bgTrafficManager_.end())
            throw cRuntimeError("LteMacEnb::getBackgroundTrafficManager - carrier frequency [%f] not valid.", carrierFrequency.get());
        return bgTrafficManager_[carrierFrequency];
    }
    virtual int getNumAntennas();
    SchedDiscipline getSchedDiscipline(Direction dir);
 
    /*
     * Return the current active set (active connections).
     * @param direction
     */
    ActiveSet *getActiveSet(Direction dir);
 
    /*
     * Inform the base station that the given node will need a retransmission.
     */
    virtual void signalProcessForRtx(MacNodeId nodeId, GHz carrierFrequency, Direction dir, bool rtx = true);
 
    /*
     * Get the number of nodes requesting retransmissions for the given carrier and direction.
     */
    virtual int getProcessForRtx(GHz carrierFrequency, Direction dir);
    virtual int getPendingRtxOtherThan(GHz carrierFrequency, Direction excluded);
 
    // Get band occupation for this/previous TTI. Used for interference computation purposes.
    unsigned int getDlBandStatus(Band b);
    unsigned int getDlPrevBandStatus(Band b);
 
    // Configuration push: RRC installs (or replaces) a bearer's QoS profile. MAC does
    // not author its own configuration; this is the only write path into the map.
    virtual void configureDrbQos(DrbKey key, const DrbQosProfile& qos);
 
    // The DRB QoS map (DrbKey -> QoS profile), as RRC pushes it. The address stays
    // valid for the module's lifetime, so a reader that takes it once (the scheduler,
    // at its creation) sees the bearers configured later too.
    const std::map<DrbKey, DrbQosProfile> *getDrbQosMap() { return &drbQosMap_; }
 
    /*
     * @author Alessandro Noferi
     * Gets percentage of block utilized during the last TTI.
     * @param dir UL or DL.
     */
    double getUtilization(Direction dir);
 
    /* Gets the number of active users based on the direction.
     * A user is active (according to TS 136 314) if:
     * - it has buffered data in MAC RLC or PDCP layers -> ActiveSet.
     * - it has data for which HARQ transmission has not yet terminated -> !EMPTY HarqBuffer.
     *
     * @param direction
     */
    int getActiveUesNumber(Direction dir);
 
};
 
} //namespace
 
#endif