RlcUmTransmitterBuffer.h Source File¶

Simu5G: RlcUmTransmitterBuffer.h Source File
Simu5G
//
//                  Simu5G
//
// Authors: Esteban Egea Lopez (Universidad Politecnica de Cartagena)
//
// 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 STACK_RLC_UM_RLCUMTRANSMITTERBUFFER_H_
#define STACK_RLC_UM_RLCUMTRANSMITTERBUFFER_H_
 
 
#include <omnetpp.h>
#include <inet/common/packet/Packet.h>
namespace simu5g {
using namespace inet;
struct TransmitInterval {
    uint32_t start;
    uint32_t end;
 
    bool operator<(const TransmitInterval& other) const {
        return start < other.start;
    }
};
struct SduUmTxState {
    uint32_t sn;
    uint32_t totalLength;
    inet::Packet* sduPointer;
    std::list<TransmitInterval> transmittedIntervals;
 
    SduUmTxState(uint32_t s, uint32_t len, Packet* ptr)
        : sn(s), totalLength(len), sduPointer(ptr) {}
    bool getNextSegment(uint32_t grantSize, uint32_t& outStart, uint32_t& outEnd) {
        uint32_t nextByteToTx = 0;
        transmittedIntervals.sort();
 
        for (const auto& interval : transmittedIntervals) {
            if (nextByteToTx < interval.start) break;
            nextByteToTx = interval.end + 1;
        }
 
        if (nextByteToTx >= totalLength) return false;
 
        outStart = nextByteToTx;
        uint32_t remainingInSdu = totalLength - nextByteToTx;
        uint32_t bytesToTransfer = std::min(grantSize, remainingInSdu);
        outEnd = outStart + bytesToTransfer - 1;
 
        return true;
    }
 
    // Offset of the first not-yet-transmitted byte (0 if nothing sent yet).
    uint32_t getNextByteToTx() const {
        uint32_t nextByteToTx = 0;
        std::list<TransmitInterval> sorted = transmittedIntervals;
        sorted.sort();
        for (const auto& interval : sorted) {
            if (nextByteToTx < interval.start) break;
            nextByteToTx = interval.end + 1;
        }
        return nextByteToTx;
    }
 
    void markTransmitted(uint32_t start, uint32_t end) {
        transmittedIntervals.push_back({start, end});
        mergeIntervals(transmittedIntervals);
    }
 
    bool isFullyTransmitted() {
        if (transmittedIntervals.empty()) return false;
        mergeIntervals(transmittedIntervals);
        return (transmittedIntervals.front().start == 0 &&
                transmittedIntervals.front().end == totalLength - 1);
    }
    uint32_t getPendingBytes() const {
        uint32_t transmittedCount = 0;
        for (const auto& interval : transmittedIntervals) {
            transmittedCount += (interval.end - interval.start + 1);
        }
        return (totalLength > transmittedCount) ? (totalLength - transmittedCount) : 0;
    }
    private:
    void mergeIntervals(std::list<TransmitInterval>& intervals) {
        if (intervals.empty()) return;
        intervals.sort();
        for (auto it = intervals.begin(); it != intervals.end(); ) {
            auto next = std::next(it);
            if (next != intervals.end() && next->start <= it->end + 1) {
                it->end = std::max(it->end, next->end);
                intervals.erase(next);
            } else {
                ++it;
            }
        }
    }
};
 
struct PendingSegmentUM {
    uint32_t sn;
    uint32_t start;
    uint32_t end;
    uint32_t totalLength;
    Packet* ptr;
    bool isValid = false;
    bool isLastSegment = false; // Added to help UM SN logic
    bool isFull=false;
};
 
class RlcUmTransmitterBuffer {
protected:
    std::list<SduUmTxState> txBuffer; // Using list for FIFO order
    uint32_t TX_Next = 0;             // Next SN to be assigned
    uint32_t snModulus;
public:
    RlcUmTransmitterBuffer(uint32_t snBits);
    virtual ~RlcUmTransmitterBuffer();
    virtual void addSdu(uint32_t length, Packet* sduPtr) {
        // In UM, we buffer the SDU and assign SN when it's picked for transmission
        txBuffer.emplace_back(0, length, sduPtr);
    }
    virtual PendingSegmentUM getSegmentForGrant(uint32_t grantSize);
 
    // Peek the head SDU without consuming it: untransmitted byte count + the offset of
    // its next byte (0 => fresh/first piece, >0 => continuation). Lets the caller pick
    // the RAT/segment-state-dependent header size before carving.
    virtual bool peekHead(uint32_t& remaining, uint32_t& nextByte) const {
        if (txBuffer.empty()) return false;
        const auto& sdu = txBuffer.front();
        nextByte = sdu.getNextByteToTx();
        remaining = (sdu.totalLength > nextByte) ? (sdu.totalLength - nextByte) : 0;
        return true;
    }
 
    virtual bool hasData() const {
        return !txBuffer.empty();
    }
    virtual uint64_t getTotalPendingBytes() const {
        uint64_t total = 0;
        for (const auto& sdu : txBuffer) {
            total += sdu.getPendingBytes();
        }
        return total;
    }
    virtual void clearBuffer() {
        for (auto& sdu : txBuffer) {
            if (sdu.sduPointer) {
                delete sdu.sduPointer;
                sdu.sduPointer = nullptr;
            }
        }
        txBuffer.clear();
    }
 
 
    uint32_t getTxNext() const { return TX_Next; }
    void resetTxNext() {TX_Next=0;}
};
 
} /* namespace simu5g */
 
#endif /* STACK_RLC_UM_RLCUMTRANSMITTERBUFFER_H_ */