LteHarqBufferRx.h Source File¶

Simu5G: LteHarqBufferRx.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_LTEHARQBUFFERRX_H_
#define _LTE_LTEHARQBUFFERRX_H_
 
#include "simu5g/stack/mac/LteMacBase.h"
#include "simu5g/stack/mac/buffer/harq/LteHarqProcessRx.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
class LteMacBase;
class LteHarqProcessRx;
class LteHarqBufferRx
{
  protected:
    opp_component_ptr<Binder> binder_;
    opp_component_ptr<LteMacBase> macOwner_;
    unsigned int numHarqProcesses_;
    MacNodeId srcId_;
    std::vector<LteHarqProcessRx *> processes_;
    bool isMulticast_;
 
    // Statistics
    unsigned int totalRcvdBytes_ = 0;
    Direction dir = UNKNOWN_DIRECTION;
 
    static simsignal_t macDelaySignal_[2];
    static simsignal_t macThroughputSignal_[2];
 
    // reference to the eNB module
 
  private:
    // LteMacBase* of the UE for which this buffer has been created (whose ID is srcId_).
    // Only access via methods. This can be nullptr if node is removed from simulation
    opp_component_ptr<LteMacBase> macUe_;
 
  protected:
    LteHarqBufferRx(Binder *binder, LteMacBase *owner, unsigned int num, MacNodeId srcId);
 
  public:
    LteHarqBufferRx(unsigned int num, LteMacBase *owner, Binder *binder, MacNodeId srcId);
    virtual void insertPdu(Codeword cw, inet::Packet *pkt);
    virtual std::list<inet::Packet *> extractCorrectPdus();
    virtual unsigned int purgeCorruptedPdus();
 
    /*
     * Returns pointer to <acid> process.
     */
    LteHarqProcessRx *getProcess(unsigned char acid)
    {
        return processes_.at(acid);
    }
 
    //* Returns the number of contained H-ARQ processes
    unsigned int getProcesses()
    {
        return numHarqProcesses_;
    }
 
    // @return whole buffer status {RXHARQ_PDU_EMPTY, RXHARQ_PDU_EVALUATING, RXHARQ_PDU_CORRECT, RXHARQ_PDU_CORRUPTED }
    virtual RxBufferStatus getBufferStatus();
    virtual UnitList firstAvailable();
 
    /*
     * Returns a pair with the specified H-ARQ process ID and a list of its empty units to be used for reception.
     */
    virtual UnitList getEmptyUnits(unsigned char acid);
 
    /*
     * returns true if the corresponding flow is a multicast one
     */
    bool isMulticast() { return isMulticast_; }
 
    /*
     *  Corresponding cModule node will be removed from simulation.
     */
    virtual void unregister_macUe() {
        macUe_ = nullptr;
    }
 
    virtual bool isHarqBufferActive() const;
 
    virtual ~LteHarqBufferRx();
 
  protected:
    virtual void sendFeedback();
    virtual void macUe_emit(simsignal_t signal, double val)
    {
        if (macUe_ != nullptr) {
            macUe_->emit(signal, val);
        }
    }
    virtual void initMacUe() {
        if (macOwner_->getNodeType() == NODEB)
            macUe_ = check_and_cast<LteMacBase *>(binder_->getMacByNodeId(srcId_));
        else
            macUe_ = macOwner_;
    }
 
};
 
} //namespace
 
#endif