inet::tcp::TCPSACKRexmitQueue Class Reference

Retransmission data for SACK. More...

#include <TCPSACKRexmitQueue.h>

Classes
struct	Region

Public Types
typedef std::list< Region >	RexmitQueue

Public Member Functions
	TCPSACKRexmitQueue ()
	Ctor. More...
virtual	~TCPSACKRexmitQueue ()
	Virtual dtor. More...
virtual void	setConnection (TCPConnection *_conn)
	Set the connection that owns this queue. More...
virtual void	init (uint32 seqNum)
	Initialize the object. More...
virtual std::string	str () const
	Returns a string for debug purposes. More...
virtual void	info () const
	Prints the current rexmitQueue status for debug purposes. More...
virtual uint32	getBufferStartSeq () const
	Returns the sequence number of the first byte stored in the buffer. More...
virtual uint32	getBufferEndSeq () const
	Returns the sequence number of the last byte stored in the buffer plus one. More...
virtual void	discardUpTo (uint32 seqNum)
	Tells the queue that bytes up to (but NOT including) seqNum have been transmitted and ACKed, so they can be removed from the queue. More...
virtual void	enqueueSentData (uint32 fromSeqNum, uint32 toSeqNum)
	Inserts sent data to the rexmit queue. More...
virtual void	setSackedBit (uint32 fromSeqNum, uint32 toSeqNum)
	Called when data sender received selective acknowledgments. More...
virtual bool	getSackedBit (uint32 seqNum) const
	Returns SackedBit value of seqNum. More...
virtual uint32	getQueueLength () const
	Returns the number of blocks currently buffered in queue. More...
virtual uint32	getHighestSackedSeqNum () const
	Returns the highest sequence number sacked by data receiver. More...
virtual uint32	getHighestRexmittedSeqNum () const
	Returns the highest sequence number rexmitted by data sender. More...
virtual uint32	checkRexmitQueueForSackedOrRexmittedSegments (uint32 fromSeq) const
	Checks rexmit queue for sacked of rexmitted segments and returns a certain offset (contiguous sacked or rexmitted region) to forward snd->nxt. More...
virtual void	resetSackedBit ()
	Called when REXMIT timer expired. More...
virtual void	resetRexmittedBit ()
	Called when REXMIT timer expired. More...
virtual uint32	getTotalAmountOfSackedBytes () const
	Returns total amount of sacked bytes. More...
virtual uint32	getAmountOfSackedBytes (uint32 seqNum) const
	Returns amount of sacked bytes above seqNum. More...
virtual uint32	getNumOfDiscontiguousSacks (uint32 seqNum) const
	Returns the number of discontiguous sacked regions (SACKed sequences) above seqNum. More...
virtual void	checkSackBlock (uint32 seqNum, uint32 &length, bool &sacked, bool &rexmitted) const

Public Attributes
TCPConnection *	conn
RexmitQueue	rexmitQueue
uint32	begin
uint32	end

Protected Member Functions
bool	checkQueue () const

Detailed Description

Retransmission data for SACK.

Member Typedef Documentation

typedef std::list<Region> inet::tcp::TCPSACKRexmitQueue::RexmitQueue

Constructor & Destructor Documentation

inet::tcp::TCPSACKRexmitQueue::TCPSACKRexmitQueue

(

)

Ctor.

{
    conn = nullptr;
    begin = end = 0;
}

inet::tcp::TCPSACKRexmitQueue::~TCPSACKRexmitQueue ( )

virtual

Virtual dtor.

{
    while (!rexmitQueue.empty())
        rexmitQueue.pop_front();
}

Member Function Documentation

bool inet::tcp::TCPSACKRexmitQueue::checkQueue ( ) const

protected

Referenced by discardUpTo(), enqueueSentData(), and setSackedBit().

{
    uint32 b = begin;
    bool f = true;

    for (const auto & elem : rexmitQueue) {
        f = f && (b == elem.beginSeqNum);
        f = f && seqLess(elem.beginSeqNum, elem.endSeqNum);
        b = elem.endSeqNum;
    }

    f = f && (b == end);

    if (!f) {
        EV_DEBUG << "Invalid Queue\nThe Queue is:\n";
        info();
    }

    return f;
}

uint32 inet::tcp::TCPSACKRexmitQueue::checkRexmitQueueForSackedOrRexmittedSegments ( uint32  fromSeq ) const

virtual

Checks rexmit queue for sacked of rexmitted segments and returns a certain offset (contiguous sacked or rexmitted region) to forward snd->nxt.

It is called before retransmitting data.

Referenced by inet::tcp::TCPConnection::sendSegment().

{
    ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));

    if (rexmitQueue.empty() || (end == fromSeqNum))
        return 0;

    RexmitQueue::const_iterator i = rexmitQueue.begin();
    uint32 bytes = 0;

    while (i != rexmitQueue.end() && seqLE(i->endSeqNum, fromSeqNum))
        i++;

    while (i != rexmitQueue.end() && ((i->sacked || i->rexmitted))) {
        ASSERT(seqLE(i->beginSeqNum, fromSeqNum) && seqLess(fromSeqNum, i->endSeqNum));

        bytes += (i->endSeqNum - fromSeqNum);
        fromSeqNum = i->endSeqNum;
        i++;
    }

    return bytes;
}

void inet::tcp::TCPSACKRexmitQueue::checkSackBlock ( uint32  seqNum, uint32 &  length, bool &  sacked, bool &  rexmitted  ) const

virtual

Referenced by inet::tcp::TCPConnection::nextSeg(), and inet::tcp::TCPConnection::setPipe().

{
    ASSERT(seqLE(begin, fromSeqNum) && seqLess(fromSeqNum, end));

    RexmitQueue::const_iterator i = rexmitQueue.begin();

    while (i != rexmitQueue.end() && seqLE(i->endSeqNum, fromSeqNum)) // search for seqNum
        i++;

    ASSERT(i != rexmitQueue.end());
    ASSERT(seqLE(i->beginSeqNum, fromSeqNum) && seqLess(fromSeqNum, i->endSeqNum));

    length = (i->endSeqNum - fromSeqNum);
    sacked = i->sacked;
    rexmitted = i->rexmitted;
}

void inet::tcp::TCPSACKRexmitQueue::discardUpTo ( uint32  seqNum )

virtual

Tells the queue that bytes up to (but NOT including) seqNum have been transmitted and ACKed, so they can be removed from the queue.

Referenced by inet::tcp::TCPConnection::processAckInEstabEtc(), inet::tcp::TCPConnection::processRstInSynReceived(), and inet::tcp::TCPConnection::processSegmentInSynSent().

{
    ASSERT(seqLE(begin, seqNum) && seqLE(seqNum, end));

    if (!rexmitQueue.empty()) {
        auto i = rexmitQueue.begin();

        while ((i != rexmitQueue.end()) && seqLE(i->endSeqNum, seqNum)) // discard/delete regions from rexmit queue, which have been acked
            i = rexmitQueue.erase(i);

        if (i != rexmitQueue.end()) {
            ASSERT(seqLE(i->beginSeqNum, seqNum) && seqLess(seqNum, i->endSeqNum));
            i->beginSeqNum = seqNum;
        }
    }

    begin = seqNum;

    // TESTING queue:
    ASSERT(checkQueue());
}

void inet::tcp::TCPSACKRexmitQueue::enqueueSentData ( uint32  fromSeqNum, uint32  toSeqNum  )

virtual

Inserts sent data to the rexmit queue.

Referenced by inet::tcp::TCPConnection::sendSegment().

{
    ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));

    bool found = false;
    Region region;

    EV_INFO << "rexmitQ: " << str() << " enqueueSentData [" << fromSeqNum << ".." << toSeqNum << ")\n";

    ASSERT(seqLess(fromSeqNum, toSeqNum));

    if (rexmitQueue.empty() || (end == fromSeqNum)) {
        region.beginSeqNum = fromSeqNum;
        region.endSeqNum = toSeqNum;
        region.sacked = false;
        region.rexmitted = false;
        rexmitQueue.push_back(region);
        found = true;
        fromSeqNum = toSeqNum;
    }
    else {
        auto i = rexmitQueue.begin();

        while (i != rexmitQueue.end() && seqLE(i->endSeqNum, fromSeqNum))
            i++;

        ASSERT(i != rexmitQueue.end());
        ASSERT(seqLE(i->beginSeqNum, fromSeqNum) && seqLess(fromSeqNum, i->endSeqNum));

        if (i->beginSeqNum != fromSeqNum) {
            // chunk item
            region = *i;
            region.endSeqNum = fromSeqNum;
            rexmitQueue.insert(i, region);
            i->beginSeqNum = fromSeqNum;
        }

        while (i != rexmitQueue.end() && seqLE(i->endSeqNum, toSeqNum)) {
            i->rexmitted = true;
            fromSeqNum = i->endSeqNum;
            found = true;
            i++;
        }

        if (fromSeqNum != toSeqNum) {
            bool beforeEnd = (i != rexmitQueue.end());

            ASSERT(i == rexmitQueue.end() || seqLess(i->beginSeqNum, toSeqNum));

            region.beginSeqNum = fromSeqNum;
            region.endSeqNum = toSeqNum;
            region.sacked = beforeEnd ? i->sacked : false;
            region.rexmitted = beforeEnd;
            rexmitQueue.insert(i, region);
            found = true;
            fromSeqNum = toSeqNum;

            if (beforeEnd)
                i->beginSeqNum = toSeqNum;
        }
    }

    ASSERT(fromSeqNum == toSeqNum);

    if (!found) {
        EV_DEBUG << "Not found enqueueSentData(" << fromSeqNum << ", " << toSeqNum << ")\nThe Queue is:\n";
        info();
    }

    ASSERT(found);

    begin = rexmitQueue.front().beginSeqNum;
    end = rexmitQueue.back().endSeqNum;

    // TESTING queue:
    ASSERT(checkQueue());

    // tcpEV << "rexmitQ: rexmitQLength=" << getQueueLength() << "\n";
}

uint32 inet::tcp::TCPSACKRexmitQueue::getAmountOfSackedBytes ( uint32  seqNum ) const

virtual

Returns amount of sacked bytes above seqNum.

Referenced by inet::tcp::TCPConnection::isLost().

{
    ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));

    uint32 bytes = 0;
    RexmitQueue::const_reverse_iterator i = rexmitQueue.rbegin();

    for ( ; i != rexmitQueue.rend() && seqLE(fromSeqNum, i->beginSeqNum); i++) {
        if (i->sacked)
            bytes += (i->endSeqNum - i->beginSeqNum);
    }

    if (i != rexmitQueue.rend()
        && seqLess(i->beginSeqNum, fromSeqNum) && seqLess(fromSeqNum, i->endSeqNum) && i->sacked)
    {
        bytes += (i->endSeqNum - fromSeqNum);
    }

    return bytes;
}

virtual uint32 inet::tcp::TCPSACKRexmitQueue::getBufferEndSeq ( ) const

inlinevirtual

Returns the sequence number of the last byte stored in the buffer plus one.

(The first byte of the next send operation would get this sequence number.)

Referenced by inet::tcp::TCPConnection::processRstInSynReceived().

{ return end; }

virtual uint32 inet::tcp::TCPSACKRexmitQueue::getBufferStartSeq ( ) const

inlinevirtual

Returns the sequence number of the first byte stored in the buffer.

{ return begin; }

uint32 inet::tcp::TCPSACKRexmitQueue::getHighestRexmittedSeqNum ( ) const

virtual

Returns the highest sequence number rexmitted by data sender.

Referenced by inet::tcp::TCPConnection::nextSeg(), inet::tcp::TCPConnection::retransmitOneSegment(), inet::tcp::TCPConnection::sendData(), inet::tcp::TCPConnection::sendSegmentDuringLossRecoveryPhase(), and inet::tcp::TCPConnection::setPipe().

{
    for (RexmitQueue::const_reverse_iterator i = rexmitQueue.rbegin(); i != rexmitQueue.rend(); i++) {
        if (i->rexmitted)
            return i->endSeqNum;
    }

    return begin;
}

uint32 inet::tcp::TCPSACKRexmitQueue::getHighestSackedSeqNum ( ) const

virtual

Returns the highest sequence number sacked by data receiver.

Referenced by inet::tcp::TCPConnection::nextSeg().

{
    for (RexmitQueue::const_reverse_iterator i = rexmitQueue.rbegin(); i != rexmitQueue.rend(); i++) {
        if (i->sacked)
            return i->endSeqNum;
    }

    return begin;
}

uint32 inet::tcp::TCPSACKRexmitQueue::getNumOfDiscontiguousSacks ( uint32  seqNum ) const

virtual

Returns the number of discontiguous sacked regions (SACKed sequences) above seqNum.

Referenced by inet::tcp::TCPConnection::isLost().

{
    ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));

    if (rexmitQueue.empty() || (fromSeqNum == end))
        return 0;

    RexmitQueue::const_iterator i = rexmitQueue.begin();
    uint32 counter = 0;

    while (i != rexmitQueue.end() && seqLE(i->endSeqNum, fromSeqNum)) // search for seqNum
        i++;

    // search for discontiguous sacked regions
    bool prevSacked = false;

    while (i != rexmitQueue.end()) {
        if (i->sacked && !prevSacked)
            counter++;

        prevSacked = i->sacked;
        i++;
    }

    return counter;
}

virtual uint32 inet::tcp::TCPSACKRexmitQueue::getQueueLength ( ) const

inlinevirtual

Returns the number of blocks currently buffered in queue.

{ return rexmitQueue.size(); }

bool inet::tcp::TCPSACKRexmitQueue::getSackedBit ( uint32  seqNum ) const

virtual

Returns SackedBit value of seqNum.

{
    ASSERT(seqLE(begin, seqNum) && seqLE(seqNum, end));

    RexmitQueue::const_iterator i = rexmitQueue.begin();

    if (end == seqNum)
        return false;

    while (i != rexmitQueue.end() && seqLE(i->endSeqNum, seqNum))
        i++;

    ASSERT((i != rexmitQueue.end()) && seqLE(i->beginSeqNum, seqNum) && seqLess(seqNum, i->endSeqNum));

    return i->sacked;
}

uint32 inet::tcp::TCPSACKRexmitQueue::getTotalAmountOfSackedBytes ( ) const

virtual

Returns total amount of sacked bytes.

Corresponds to update() function from RFC 3517.

Referenced by inet::tcp::TCPConnection::processSACKOption().

{
    uint32 bytes = 0;

    for (const auto & elem : rexmitQueue) {
        if (elem.sacked)
            bytes += (elem.endSeqNum - elem.beginSeqNum);
    }

    return bytes;
}

void inet::tcp::TCPSACKRexmitQueue::info ( ) const

virtual

Prints the current rexmitQueue status for debug purposes.

Referenced by checkQueue(), enqueueSentData(), and inet::tcp::TCPConnection::sendSegment().

{
    EV_DETAIL << str() << endl;

    uint j = 1;

    for (const auto & elem : rexmitQueue) {
        EV_DETAIL << j << ". region: [" << elem.beginSeqNum << ".." << elem.endSeqNum
                  << ") \t sacked=" << elem.sacked << "\t rexmitted=" << elem.rexmitted
                  << endl;
        j++;
    }
}

void inet::tcp::TCPSACKRexmitQueue::init ( uint32  seqNum )

virtual

Initialize the object.

The startSeq parameter tells what sequence number the first byte of app data should get. This is usually ISS + 1 because SYN consumes one byte in the sequence number space.

init() may be called more than once; every call flushes the existing contents of the queue.

Referenced by inet::tcp::TCPConnection::selectInitialSeqNum().

{
    begin = seqNum;
    end = seqNum;
}

void inet::tcp::TCPSACKRexmitQueue::resetRexmittedBit ( )

virtual

Called when REXMIT timer expired.

Resets rexmitted bit of all segments in rexmit queue.

Referenced by inet::tcp::TCPBaseAlg::processRexmitTimer().

{
    for (auto & elem : rexmitQueue)
        elem.rexmitted = false; // reset rexmitted bit
}

void inet::tcp::TCPSACKRexmitQueue::resetSackedBit ( )

virtual

Called when REXMIT timer expired.

Resets sacked bit of all segments in rexmit queue.

Referenced by inet::tcp::TCPBaseAlg::processRexmitTimer().

{
    for (auto & elem : rexmitQueue)
        elem.sacked = false; // reset sacked bit
}

virtual void inet::tcp::TCPSACKRexmitQueue::setConnection ( TCPConnection *  _conn )

inlinevirtual

Set the connection that owns this queue.

Referenced by inet::tcp::TCPConnection::cloneListeningConnection(), and inet::tcp::TCPConnection::initConnection().

{ conn = _conn; }

void inet::tcp::TCPSACKRexmitQueue::setSackedBit ( uint32  fromSeqNum, uint32  toSeqNum  )

virtual

Called when data sender received selective acknowledgments.

Tells the queue which bytes have been transmitted and SACKed, so they can be skipped if retransmitting segments as long as REXMIT timer did not expired.

Referenced by inet::tcp::TCPConnection::processSACKOption().

{
    if (seqLess(fromSeqNum, begin))
        fromSeqNum = begin;

    ASSERT(seqLess(fromSeqNum, end));
    ASSERT(seqLess(begin, toSeqNum) && seqLE(toSeqNum, end));
    ASSERT(seqLess(fromSeqNum, toSeqNum));

    bool found = false;

    if (!rexmitQueue.empty()) {
        auto i = rexmitQueue.begin();

        while (i != rexmitQueue.end() && seqLE(i->endSeqNum, fromSeqNum))
            i++;

        ASSERT(i != rexmitQueue.end() && seqLE(i->beginSeqNum, fromSeqNum) && seqLess(fromSeqNum, i->endSeqNum));

        if (i->beginSeqNum != fromSeqNum) {
            Region region = *i;

            region.endSeqNum = fromSeqNum;
            rexmitQueue.insert(i, region);
            i->beginSeqNum = fromSeqNum;
        }

        while (i != rexmitQueue.end() && seqLE(i->endSeqNum, toSeqNum)) {
            if (seqGE(i->beginSeqNum, fromSeqNum)) {    // Search region in queue!
                found = true;
                i->sacked = true;    // set sacked bit
            }

            i++;
        }

        if (i != rexmitQueue.end() && seqLess(i->beginSeqNum, toSeqNum) && seqLess(toSeqNum, i->endSeqNum)) {
            Region region = *i;

            region.endSeqNum = toSeqNum;
            region.sacked = true;
            rexmitQueue.insert(i, region);
            i->beginSeqNum = toSeqNum;
        }
    }

    if (!found)
        EV_DETAIL << "FAILED to set sacked bit for region: [" << fromSeqNum << ".." << toSeqNum << "). Not found in retransmission queue.\n";

    ASSERT(checkQueue());
}

std::string inet::tcp::TCPSACKRexmitQueue::str ( ) const

virtual

Returns a string for debug purposes.

Referenced by enqueueSentData(), and info().

{
    std::stringstream out;

    out << "[" << begin << ".." << end << ")";
    return out.str();
}

Member Data Documentation

uint32 inet::tcp::TCPSACKRexmitQueue::begin

Referenced by checkQueue(), checkRexmitQueueForSackedOrRexmittedSegments(), checkSackBlock(), discardUpTo(), enqueueSentData(), getAmountOfSackedBytes(), getHighestRexmittedSeqNum(), getHighestSackedSeqNum(), getNumOfDiscontiguousSacks(), getSackedBit(), init(), setSackedBit(), str(), and TCPSACKRexmitQueue().

TCPConnection* inet::tcp::TCPSACKRexmitQueue::conn

Referenced by TCPSACKRexmitQueue().

uint32 inet::tcp::TCPSACKRexmitQueue::end

Referenced by checkQueue(), checkRexmitQueueForSackedOrRexmittedSegments(), checkSackBlock(), discardUpTo(), enqueueSentData(), getAmountOfSackedBytes(), getNumOfDiscontiguousSacks(), getSackedBit(), init(), setSackedBit(), str(), and TCPSACKRexmitQueue().

RexmitQueue inet::tcp::TCPSACKRexmitQueue::rexmitQueue

Referenced by checkQueue(), checkRexmitQueueForSackedOrRexmittedSegments(), checkSackBlock(), discardUpTo(), enqueueSentData(), getAmountOfSackedBytes(), getHighestRexmittedSeqNum(), getHighestSackedSeqNum(), getNumOfDiscontiguousSacks(), getSackedBit(), getTotalAmountOfSackedBytes(), info(), resetRexmittedBit(), resetSackedBit(), setSackedBit(), and ~TCPSACKRexmitQueue().

---

The documentation for this class was generated from the following files:

• TCPSACKRexmitQueue.h
• TCPSACKRexmitQueue.cc