LteAllocationModule.h Source File¶

Simu5G: LteAllocationModule.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_LTEALLOCATIONMODULE_H_
#define _LTE_LTEALLOCATIONMODULE_H_
 
#include "simu5g/common/LteCommon.h"
#include "simu5g/stack/mac/allocator/LteAllocatorUtils.h"
 
#include "simu5g/stack/mac/LteMacEnb.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
class LteMacEnb;
 
class LteAllocationModule
{
    // Members *********************************************************************************
 
    // --- General Parameters ------------------------------------------------------------------
 
  protected:
    opp_component_ptr<LteMacEnb> mac_;
    unsigned int bands_ = 0;
    Direction dir_;
    bool usedInLastSlot_ = false;
 
    /*
     * We will consider the following two planes
     *
     * plane
     *  [0]      represents the main OFDMA space
     *  [1]      the space obtained by summing all the Mu-Mimo spaces
     */
 
    // *************************** RESOURCE BLOCKS MATRIX ***************************
    std::vector<std::vector<unsigned int>> totalRbsMatrix_;
    std::vector<std::vector<unsigned int>> allocatedRbsMatrix_;
    std::vector<std::vector<std::vector<unsigned int>>> freeRbsMatrix_;
 
    /************************************************************
    *    From UE to Logical Band
    ************************************************************/
 
  public:
 
    // Amount of bytes served by a single set of allocated blocks
    struct AllocationElem
    {
        unsigned int resourceBlocks_;
        unsigned int bytes_;
    };
 
    typedef std::list<AllocationElem> AllocationList;
 
    typedef std::map<Band, AllocationList> PerBandAllocationMap;
 
    typedef std::map<Band, unsigned int> PerBandAllocatedRbsMap;
    struct AllocatedRbsPerUeInfo
    {
        unsigned int allocatedBlocks_ = 0;
        unsigned int allocatedBytes_ = 0;
 
        // amount of blocks allocated for this UE for each remote and for each band
        std::map<Remote, PerBandAllocatedRbsMap> ueAllocatedRbsMap_;
        std::map<Remote, PerBandAllocationMap> allocationMap_;
        // amount of blocks allocated for this UE for each remote
        std::map<Remote, unsigned int> antennaAllocatedRbs_;
 
        // antennas available for this user
        RemoteSet availableAntennaSet_;
 
        // first available antenna
        Remote currentAntenna_ = MACRO;
 
      public:
 
        AllocatedRbsPerUeInfo()
        {
            availableAntennaSet_.insert(MACRO);
        }
    };
 
    typedef std::map<MacNodeId, AllocatedRbsPerUeInfo> AllocatedRbsPerUeMap;
 
    // b) Variables
 
  protected:
    AllocatedRbsPerUeMap allocatedRbsUe_;
 
  private:
    virtual void ensureNodeInitialized(const MacNodeId nodeId);
 
    /************************************************************
    *   From Logical Bands to UE
    ************************************************************/
 
  public:
 
    typedef std::map<MacNodeId, unsigned int> UeAllocatedBlocksMap;
    typedef std::map<MacNodeId, unsigned int> UeAllocatedBytesMap;
    struct AllocatedRbsPerBandInfo
    {
        UeAllocatedBlocksMap ueAllocatedRbsMap_;
        UeAllocatedBytesMap ueAllocatedBytesMap_;
        unsigned int allocated_ = 0;
 
        AllocatedRbsPerBandInfo()
        {
        }
 
        friend std::ostream& operator<<(std::ostream& os, const AllocatedRbsPerBandInfo& e) {
            os << "allocated=" << e.allocated_ << " ueRbs=" << e.ueAllocatedRbsMap_.size()
               << " ueBytes=" << e.ueAllocatedBytesMap_.size();
            return os;
        }
    };
 
    typedef std::map<Band, AllocatedRbsPerBandInfo> AllocatedRbsPerBandMap;
 
  protected:
    std::vector<std::vector<AllocatedRbsPerBandMap>> allocatedRbsPerBand_;
 
    /*
     * Stores the block-allocation info of the previous TTI in order to use it for interference computation
     */
    std::vector<std::vector<AllocatedRbsPerBandMap>> prevAllocatedRbsPerBand_;
 
  public:
    LteAllocationModule(LteMacEnb *mac, const Direction direction);
    virtual ~LteAllocationModule() {}
 
    // init Allocation Module structure
    virtual void init(const unsigned int resourceBlocks, const unsigned int bands);
 
    // reset Allocation Module structure
    virtual void reset(const unsigned int resourceBlocks, const unsigned int bands);
 
    // ************** Resource Blocks Allocation Status **************
    // Returns the amount of available blocks in the whole system
    virtual unsigned int computeTotalRbs();
 
    // returns the amount of free blocks for the given band in the given plane
    virtual unsigned int availableBlocks(const MacNodeId nodeId, const Plane plane, const Band band);
 
    // returns the amount of free blocks for the given band and for the given antenna
    virtual unsigned int availableBlocks(const MacNodeId nodeId, const Remote antenna, const Band band);
    // ***************************************************************
 
    // ************** Resource Blocks Allocation Methods **************
    // tries to satisfy the resource block request in the given band and for the given antenna
    bool addBlocks(const Remote antenna, const Band band, const MacNodeId nodeId, const unsigned int blocks,
            const unsigned int bytes);
 
    // tries to satisfy the resource block request in the first available antenna
    virtual bool addBlocks(const Band band, const MacNodeId nodeId, const unsigned int blocks, const unsigned int bytes);
 
    // remove resource Blocks previously allocated in a band by a UE
    virtual unsigned int removeBlocks(const Remote antenna, const Band band, const MacNodeId nodeId);
    // ****************************************************************
 
    // --- Get (Parameters) --------------------------------------------------------------------
 
    // Simple block-amount returning methods
    unsigned int getBlocks(const Remote antenna, const Band band, const MacNodeId nodeId)
    {
        Plane plane = MAIN_PLANE;
        return allocatedRbsPerBand_[plane][antenna][band].ueAllocatedRbsMap_[nodeId];
    }
 
    /*
     * Returns the amount of blocks allocated in a Band
     */
    virtual unsigned int getAllocatedBlocks(Plane plane, const Remote antenna, const Band band);
    virtual unsigned int getInterferingBlocks(Plane plane, const Remote antenna, const Band band);
 
    unsigned int getBytes(const Remote antenna, const Band band, const MacNodeId nodeId)
    {
        Plane plane = MAIN_PLANE;
        return allocatedRbsPerBand_[plane][antenna][band].ueAllocatedBytesMap_[nodeId];
    }
 
    // computes the amount of blocks allocated by the given UE
    unsigned int getBlocks(const MacNodeId nodeId)
    {
        return allocatedRbsUe_[nodeId].allocatedBlocks_;
    }
 
    // computes the amount of blocks allocated for the given plane and the given antenna
    unsigned int getBlocks(const Plane plane, const Remote antenna)
    {
        return allocatedRbsMatrix_[plane][antenna];
    }
 
    virtual unsigned int rbOccupation(const MacNodeId nodeId, RbMap& rbMap);
 
    // --------- Map Iteration Methods --------->
    AllocatedRbsPerUeMap::const_iterator getAllocatedBlocksUeBegin()
    {
        return allocatedRbsUe_.begin();
    }
 
    AllocatedRbsPerUeMap::const_iterator getAllocatedBlocksUeEnd()
    {
        return allocatedRbsUe_.end();
    }
 
    std::vector<std::vector<unsigned int>>::const_iterator getAllocatedBlocksBegin()
    {
        return allocatedRbsMatrix_.begin();
    }
 
    std::vector<std::vector<unsigned int>>::const_iterator getAllocatedBlocksEnd()
    {
        return allocatedRbsMatrix_.end();
    }
 
    //  Band Allocation Map
    AllocationList::const_iterator getAllocatedBlocksUeAllocationListBegin(const Remote antenna, const Band b,
            const MacNodeId nodeId)
    {
        return allocatedRbsUe_[nodeId].allocationMap_[antenna][b].begin();
    }
 
    AllocationList::const_iterator getAllocatedBlocksUeAllocationListEnd(const Remote antenna, const Band b,
            const MacNodeId nodeId)
    {
        return allocatedRbsUe_[nodeId].allocationMap_[antenna][b].end();
    }
 
    /*
     *  Support for allocation with frequency reuse
     */
 
    // Store the Allocation based on passed parameters
    virtual void storeAllocation(std::vector<std::vector<AllocatedRbsPerBandMapA>> allocatedRbsPerBand, std::set<Band> *untouchableBands = nullptr)
    {
        return;
    }
 
    // Get the bands already allocated
    virtual std::set<Band> getAllocatorOccupiedBands()
    {
        std::set<Band> bandVector;
        return bandVector;
    }
 
    // returns the number of logical bands
    unsigned int getNumBands()
    {
        return bands_;
    }
 
};
 
} //namespace
 
#endif
 