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_t seqNum)
	Initialize the object. More...

virtual std::string	str () const
	Returns a string for debug purposes. More...

virtual std::string	detailedInfo () const
	Prints the current rexmitQueue status for debug purposes. More...

virtual uint32_t	getBufferStartSeq () const
	Returns the sequence number of the first byte stored in the buffer. More...

virtual uint32_t	getBufferEndSeq () const
	Returns the sequence number of the last byte stored in the buffer plus one. More...

virtual void	discardUpTo (uint32_t 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_t fromSeqNum, uint32_t toSeqNum)
	Inserts sent data to the rexmit queue. More...

virtual void	setSackedBit (uint32_t fromSeqNum, uint32_t toSeqNum)
	Called when data sender received selective acknowledgments. More...

virtual bool	getSackedBit (uint32_t seqNum) const
	Returns SackedBit value of seqNum. More...

virtual uint32_t	getQueueLength () const
	Returns the number of blocks currently buffered in queue. More...

virtual uint32_t	getHighestSackedSeqNum () const
	Returns the highest sequence number sacked by data receiver. More...

virtual uint32_t	getHighestRexmittedSeqNum () const
	Returns the highest sequence number rexmitted by data sender. More...

virtual uint32_t	checkRexmitQueueForSackedOrRexmittedSegments (uint32_t 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_t	getTotalAmountOfSackedBytes () const
	Returns total amount of sacked bytes. More...

virtual uint32_t	getAmountOfSackedBytes (uint32_t seqNum) const
	Returns amount of sacked bytes above seqNum. More...

virtual uint32_t	getNumOfDiscontiguousSacks (uint32_t seqNum) const
	Returns the number of discontiguous sacked regions (SACKed sequences) above seqNum. More...

virtual void	checkSackBlock (uint32_t seqNum, uint32_t &length, bool &sacked, bool &rexmitted) const

Public Attributes
TcpConnection *	conn

RexmitQueue	rexmitQueue

uint32_t	begin

uint32_t	end

Protected Member Functions
bool	checkQueue () const

Detailed Description

Retransmission data for SACK.

Member Typedef Documentation

◆ RexmitQueue

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

Constructor & Destructor Documentation

◆ TcpSackRexmitQueue()

inet::tcp::TcpSackRexmitQueue::TcpSackRexmitQueue ( )

Ctor.

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

◆ ~TcpSackRexmitQueue()

inet::tcp::TcpSackRexmitQueue::~TcpSackRexmitQueue ( )

virtual

Virtual dtor.

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

Member Function Documentation

◆ checkQueue()

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

protected

 {
     uint32_t 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" << detailedInfo();
     }
  
     return f;
 }

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

◆ checkRexmitQueueForSackedOrRexmittedSegments()

uint32_t inet::tcp::TcpSackRexmitQueue::checkRexmitQueueForSackedOrRexmittedSegments ( uint32_t 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.

 {
     ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));
  
     if (rexmitQueue.empty() || (end == fromSeqNum))
         return 0;
  
     RexmitQueue::const_iterator i = rexmitQueue.begin();
     uint32_t 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;
 }

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

◆ checkSackBlock()

void inet::tcp::TcpSackRexmitQueue::checkSackBlock	(	uint32_t	seqNum,
		uint32_t &	length,
		bool &	sacked,
		bool &	rexmitted
	)		const

virtual

 {
     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;
 }

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

◆ detailedInfo()

std::string inet::tcp::TcpSackRexmitQueue::detailedInfo ( ) const

virtual

Prints the current rexmitQueue status for debug purposes.

 {
     std::stringstream out;
     out << str() << endl;
  
     uint j = 1;
  
     for (const auto& elem : rexmitQueue) {
         out << j << ". region: [" << elem.beginSeqNum << ".." << elem.endSeqNum
             << ") \t sacked=" << elem.sacked << "\t rexmitted=" << elem.rexmitted
             << endl;
         j++;
     }
     return out.str();
 }

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

◆ discardUpTo()

void inet::tcp::TcpSackRexmitQueue::discardUpTo ( uint32_t 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.

 {
     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());
 }

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

◆ enqueueSentData()

void inet::tcp::TcpSackRexmitQueue::enqueueSentData	(	uint32_t	fromSeqNum,
		uint32_t	toSeqNum
	)

virtual

Inserts sent data to the rexmit queue.

 {
     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" << detailedInfo();
     }
  
     ASSERT(found);
  
     begin = rexmitQueue.front().beginSeqNum;
     end = rexmitQueue.back().endSeqNum;
  
     // TESTING queue:
     ASSERT(checkQueue());
  
 //    tcpEV << "rexmitQ: rexmitQLength=" << getQueueLength() << "\n";
 }

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

◆ getAmountOfSackedBytes()

uint32_t inet::tcp::TcpSackRexmitQueue::getAmountOfSackedBytes ( uint32_t seqNum ) const

virtual

Returns amount of sacked bytes above seqNum.

 {
     ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));
  
     uint32_t 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;
 }

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

◆ getBufferEndSeq()

virtual uint32_t 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.)

82 { return end; }

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

◆ getBufferStartSeq()

virtual uint32_t inet::tcp::TcpSackRexmitQueue::getBufferStartSeq ( ) const

inlinevirtual

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

76 { return begin; }

◆ getHighestRexmittedSeqNum()

uint32_t inet::tcp::TcpSackRexmitQueue::getHighestRexmittedSeqNum ( ) const

virtual

Returns the highest sequence number rexmitted by data sender.

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

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

◆ getHighestSackedSeqNum()

uint32_t inet::tcp::TcpSackRexmitQueue::getHighestSackedSeqNum ( ) const

virtual

Returns the highest sequence number sacked by data receiver.

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

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

◆ getNumOfDiscontiguousSacks()

uint32_t inet::tcp::TcpSackRexmitQueue::getNumOfDiscontiguousSacks ( uint32_t seqNum ) const

virtual

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

 {
     ASSERT(seqLE(begin, fromSeqNum) && seqLE(fromSeqNum, end));
  
     if (rexmitQueue.empty() || (fromSeqNum == end))
         return 0;
  
     RexmitQueue::const_iterator i = rexmitQueue.begin();
     uint32_t 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;
 }

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

◆ getQueueLength()

virtual uint32_t inet::tcp::TcpSackRexmitQueue::getQueueLength ( ) const

inlinevirtual

Returns the number of blocks currently buffered in queue.

111 { return rexmitQueue.size(); }

◆ getSackedBit()

bool inet::tcp::TcpSackRexmitQueue::getSackedBit ( uint32_t 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;
 }

◆ getTotalAmountOfSackedBytes()

uint32_t inet::tcp::TcpSackRexmitQueue::getTotalAmountOfSackedBytes ( ) const

virtual

Returns total amount of sacked bytes.

Corresponds to update() function from RFC 3517.

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

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

◆ init()

void inet::tcp::TcpSackRexmitQueue::init ( uint32_t 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.

 {
     begin = seqNum;
     end = seqNum;
 }

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

◆ resetRexmittedBit()

void inet::tcp::TcpSackRexmitQueue::resetRexmittedBit ( )

virtual

Called when REXMIT timer expired.

Resets rexmitted bit of all segments in rexmit queue.

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

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

◆ resetSackedBit()

void inet::tcp::TcpSackRexmitQueue::resetSackedBit ( )

virtual

Called when REXMIT timer expired.

Resets sacked bit of all segments in rexmit queue.

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

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

◆ setConnection()

virtual void inet::tcp::TcpSackRexmitQueue::setConnection ( TcpConnection * _conn )

inlinevirtual

Set the connection that owns this queue.

51 { conn = _conn; }

Referenced by inet::tcp::TcpConnection::initClonedConnection(), and inet::tcp::TcpConnection::initConnection().

◆ setSackedBit()

void inet::tcp::TcpSackRexmitQueue::setSackedBit	(	uint32_t	fromSeqNum,
		uint32_t	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.

 {
     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());
 }

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

◆ str()

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

virtual

Returns a string for debug purposes.

 {
     std::stringstream out;
  
     out << "[" << begin << ".." << end << ")";
     return out.str();
 }

Referenced by detailedInfo(), and enqueueSentData().

Member Data Documentation

◆ begin

uint32_t inet::tcp::TcpSackRexmitQueue::begin

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

◆ conn

TcpConnection* inet::tcp::TcpSackRexmitQueue::conn

Referenced by TcpSackRexmitQueue().

◆ end

uint32_t inet::tcp::TcpSackRexmitQueue::end

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

◆ rexmitQueue

RexmitQueue inet::tcp::TcpSackRexmitQueue::rexmitQueue

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

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

Classes

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ RexmitQueue

Constructor & Destructor Documentation

◆ TcpSackRexmitQueue()

◆ ~TcpSackRexmitQueue()

Member Function Documentation

◆ checkQueue()

◆ checkRexmitQueueForSackedOrRexmittedSegments()

◆ checkSackBlock()

◆ detailedInfo()

◆ discardUpTo()

◆ enqueueSentData()

◆ getAmountOfSackedBytes()

◆ getBufferEndSeq()

◆ getBufferStartSeq()

◆ getHighestRexmittedSeqNum()

◆ getHighestSackedSeqNum()

◆ getNumOfDiscontiguousSacks()

◆ getQueueLength()

◆ getSackedBit()

◆ getTotalAmountOfSackedBytes()

◆ init()

◆ resetRexmittedBit()

◆ resetSackedBit()

◆ setConnection()

◆ setSackedBit()

◆ str()

Member Data Documentation

◆ begin

◆ conn

◆ end

◆ rexmitQueue