RlcSduSlidingWindowReceptionBuffer.h Source File¶

Simu5G: RlcSduSlidingWindowReceptionBuffer.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_AM_BUFFER_RLCSDUSLIDINGWINDOWRECEPTIONBUFFER_H_
#define STACK_RLC_AM_BUFFER_RLCSDUSLIDINGWINDOWRECEPTIONBUFFER_H_
 
#include <omnetpp.h>
#include <inet/common/packet/Packet.h>
 
#include <algorithm>
#include <list>
#include <map>
 
#include "simu5g/stack/rlc/LteRlcDefs.h"
 
namespace simu5g {
struct ByteInterval {
    uint32_t start;
    uint32_t end;
 
    // Sort by start position for easy merging
    bool operator<(const ByteInterval& other) const {
        return start < other.start;
    }
};
struct SduReassemblyState {
    uint32_t totalLength;
    inet::Packet *sduPointer;
    std::list<ByteInterval> receivedIntervals;
    bool isComplete;
 
    SduReassemblyState(uint32_t length, inet::Packet *ptr)
        : totalLength(length), sduPointer(ptr), isComplete(false) {}
    std::pair<bool, bool> addSegment(uint32_t start, uint32_t end) {
        if (isComplete)
            return {false, true};
        if (end >= totalLength)
            end = totalLength - 1;
 
        // Check if already fully covered
        for (const auto &interval : receivedIntervals) {
            if (start >= interval.start && end <= interval.end)
                return {false, isComplete};
        }
 
        ByteInterval newInterval{start, end};
        auto it = std::lower_bound(receivedIntervals.begin(), receivedIntervals.end(), newInterval);
        receivedIntervals.insert(it, newInterval);
 
        // Merge overlapping/adjacent intervals
        for (auto current = receivedIntervals.begin(); current != receivedIntervals.end(); ) {
            auto next = std::next(current);
            if (next != receivedIntervals.end() && next->start <= current->end + 1) {
                current->end = std::max(current->end, next->end);
                receivedIntervals.erase(next);
            }
            else {
                ++current;
            }
        }
 
        // Check completion: single interval covering [0, totalLength-1]
        if (!receivedIntervals.empty()) {
            const auto &first = receivedIntervals.front();
            if (first.start == 0 && first.end == totalLength - 1)
                isComplete = true;
        }
 
        return {true, isComplete};
    }
    bool hasMissingByteSegmentBeforeLast() const {
        if (receivedIntervals.empty())
            return false;
        if (receivedIntervals.size() > 1)
            return true;
        return receivedIntervals.front().start != 0;
    }
};
 
class RlcSduSlidingWindowReceptionBuffer : public omnetpp::cObject
{
  public:
    RlcSduSlidingWindowReceptionBuffer(uint32_t windowSize, const std::string &name);
    ~RlcSduSlidingWindowReceptionBuffer() override;
    std::pair<bool, bool> handleSegment(uint32_t sn, uint32_t totalSduLength,
                                        uint32_t start, uint32_t end,
                                        inet::Packet *sduDataPtr);
    virtual inet::Packet *consumeSdu(uint32_t sn);
    virtual bool hasMissingByteSegmentBeforeLast(uint32_t sn);
    virtual void handleReassemblyTimerExpiry(uint32_t rxNextStatusTrigger);
    virtual StatusPduData generateStatusPduData();
    virtual void updateRxHighestStatus();
    virtual void updateRxNext();
 
    virtual bool isReady(uint32_t sn) const {
        auto it = sduBuffer_.find(sn);
        return it != sduBuffer_.end() && it->second.isComplete;
    }
 
    virtual bool inWindow(uint32_t sn) const {
        return sn >= rxNext_ && sn < rxNext_ + amWindowSize_;
    }
 
    virtual bool aboveWindow(uint32_t sn) const {
        return sn >= rxNext_ + amWindowSize_;
    }
 
    void discardSdu(uint32_t sn) { sduBuffer_.erase(sn); }
 
    uint32_t getRxNext() const { return rxNext_; }
    uint32_t getRxNextHighest() const { return rxNextHighest_; }
    uint32_t getRxHighestStatus() const { return rxHighestStatus_; }
 
  protected:
    std::map<uint32_t, SduReassemblyState> sduBuffer_;
 
    // RLC AM reception state variables
    uint32_t rxNext_ = 0;           // Lower edge of the receiving window
    uint32_t rxNextHighest_ = 0;    // SN following highest SN received
    uint32_t rxHighestStatus_ = 0;  // SN following highest delivered SDU
    uint32_t amWindowSize_;
    uint32_t consumed_ = 0;
    std::string name_;
};
 
} // namespace simu5g
 
#endif // STACK_RLC_AM_BUFFER_RLCSDUSLIDINGWINDOWRECEPTIONBUFFER_H_