inet::tcp::TcpReceiveQueue Class Reference

Receive queue that manages Chunks. More...

#include <TcpReceiveQueue.h>

Inheritance diagram for inet::tcp::TcpReceiveQueue:

Public Member Functions
	TcpReceiveQueue ()
	Ctor. More...
virtual	~TcpReceiveQueue ()
	Virtual dtor. More...
virtual ReorderBuffer &	getReorderBuffer ()
virtual void	setConnection (TcpConnection *_conn)
	Set the connection that owns this queue. More...
virtual void	init (uint32_t startSeq)
	Set initial receive sequence number. More...
virtual std::string	str () const override
virtual uint32_t	insertBytesFromSegment (Packet *tcpSegment, const Ptr< const TcpHeader > &tcpHeader)
	Called when a TCP segment arrives, it should extract the payload from the segment and store it in the receive queue. More...
virtual Packet *	extractBytesUpTo (uint32_t seq)
	Should create a packet to be passed up to the app, up to (but NOT including) the given sequence no (usually rcv_nxt). More...
virtual uint32_t	getAmountOfBufferedBytes ()
	Returns the number of bytes (out-of-order-segments) currently buffered in queue. More...
virtual uint32_t	getAmountOfFreeBytes (uint32_t maxRcvBuffer)
	Returns the number of bytes currently free (=available) in queue. More...
virtual uint32_t	getQueueLength ()
	Returns the number of blocks currently buffered in queue. More...
virtual void	getQueueStatus ()
	Shows current queue status. More...
virtual uint32_t	getLE (uint32_t fromSeqNum)
	Returns left edge of enqueued region. More...
virtual uint32_t	getRE (uint32_t toSeqNum)
	Returns right edge of enqueued region. More...
virtual uint32_t	getFirstSeqNo ()
	Returns the minimum of first byte seq.no. More...

Protected Member Functions
uint32_t	offsetToSeq (B offs) const
B	seqToOffset (uint32_t seq) const

Protected Attributes
TcpConnection *	conn = nullptr
uint32_t	rcv_nxt = 0
ReorderBuffer	reorderBuffer

Detailed Description

Receive queue that manages Chunks.

See also

TcpSendQueue

Constructor & Destructor Documentation

TcpReceiveQueue()

inet::tcp::TcpReceiveQueue::TcpReceiveQueue

(

)

Ctor.

                                 :
    rcv_nxt(-1)
{
}

~TcpReceiveQueue()

inet::tcp::TcpReceiveQueue::~TcpReceiveQueue ( )

virtual

Virtual dtor.

{
}

Member Function Documentation

extractBytesUpTo()

Packet * inet::tcp::TcpReceiveQueue::extractBytesUpTo ( uint32_t  seq )

virtual

Should create a packet to be passed up to the app, up to (but NOT including) the given sequence no (usually rcv_nxt).

It should return nullptr if there's no more data to be passed up – this method is called several times until it returns nullptr.

{
    ASSERT(seqLE(seq, rcv_nxt));
 
    if (reorderBuffer.isEmpty())
        return nullptr;
 
    auto seqOffs = seqToOffset(seq);
    auto maxLength = seqOffs - reorderBuffer.getExpectedOffset();
    if (maxLength <= b(0))
        return nullptr;
    auto chunk = reorderBuffer.popAvailableData(maxLength);
    ASSERT(reorderBuffer.getExpectedOffset() <= seqToOffset(seq));
 
    if (chunk) {
        Packet *msg = new Packet("data");
        msg->insertAtBack(chunk);
        return msg;
    }
 
    return nullptr;
}

Referenced by inet::tcp::TcpConnection::process_READ_REQUEST(), and inet::tcp::TcpConnection::sendAvailableDataToApp().

getAmountOfBufferedBytes()

uint32_t inet::tcp::TcpReceiveQueue::getAmountOfBufferedBytes ( )

virtual

Returns the number of bytes (out-of-order-segments) currently buffered in queue.

{
    uint32_t bytes = 0;
 
    for (int i = 0; i < reorderBuffer.getNumRegions(); i++)
        bytes += B(reorderBuffer.getRegionLength(i)).get();
 
    return bytes;
}

Referenced by getAmountOfFreeBytes(), inet::tcp::TcpConnection::processSegment1stThru8th(), and inet::tcp::TcpConnection::sendAvailableDataToApp().

getAmountOfFreeBytes()

uint32_t inet::tcp::TcpReceiveQueue::getAmountOfFreeBytes ( uint32_t  maxRcvBuffer )

virtual

Returns the number of bytes currently free (=available) in queue.

freeRcvBuffer = maxRcvBuffer - usedRcvBuffer

{
    uint32_t usedRcvBuffer = getAmountOfBufferedBytes();
    uint32_t freeRcvBuffer = maxRcvBuffer - usedRcvBuffer;
    return (maxRcvBuffer > usedRcvBuffer) ? freeRcvBuffer : 0;
}

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

getFirstSeqNo()

uint32_t inet::tcp::TcpReceiveQueue::getFirstSeqNo ( )

virtual

Returns the minimum of first byte seq.no.

in queue and rcv_nxt

{
    if (reorderBuffer.getNumRegions() == 0)
        return rcv_nxt;
    return seqMin(offsetToSeq(reorderBuffer.getRegionStartOffset(0)), rcv_nxt);
}

Referenced by inet::tcp::TcpConnection::hasEnoughSpaceForSegmentInReceiveQueue(), and inet::tcp::TcpConnection::writeHeaderOptions().

getLE()

uint32_t inet::tcp::TcpReceiveQueue::getLE ( uint32_t  fromSeqNum )

virtual

Returns left edge of enqueued region.

{
    B fs = seqToOffset(fromSeqNum);
 
    for (int i = 0; i < reorderBuffer.getNumRegions(); i++) {
        if (reorderBuffer.getRegionStartOffset(i) <= fs && fs < reorderBuffer.getRegionEndOffset(i))
            return offsetToSeq(reorderBuffer.getRegionStartOffset(i));
    }
 
    return fromSeqNum;
}

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

getQueueLength()

uint32_t inet::tcp::TcpReceiveQueue::getQueueLength ( )

virtual

Returns the number of blocks currently buffered in queue.

{
    return reorderBuffer.getNumRegions();
}

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

getQueueStatus()

void inet::tcp::TcpReceiveQueue::getQueueStatus ( )

virtual

Shows current queue status.

{
    EV_DEBUG << "receiveQLength=" << reorderBuffer.getNumRegions() << " " << str() << "\n";
}

getRE()

uint32_t inet::tcp::TcpReceiveQueue::getRE ( uint32_t  toSeqNum )

virtual

Returns right edge of enqueued region.

{
    B fs = seqToOffset(toSeqNum);
 
    for (int i = 0; i < reorderBuffer.getNumRegions(); i++) {
        if (reorderBuffer.getRegionStartOffset(i) < fs && fs <= reorderBuffer.getRegionEndOffset(i))
            return offsetToSeq(reorderBuffer.getRegionEndOffset(i));
    }
 
    return toSeqNum;
}

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

getReorderBuffer()

virtual ReorderBuffer& inet::tcp::TcpReceiveQueue::getReorderBuffer ( )

inlinevirtual

{ return reorderBuffer; }

init()

void inet::tcp::TcpReceiveQueue::init ( uint32_t  startSeq )

virtual

Set initial receive sequence number.

{
    rcv_nxt = startSeq;
 
    reorderBuffer.clear();
    reorderBuffer.setExpectedOffset(B(startSeq));
}

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

insertBytesFromSegment()

uint32_t inet::tcp::TcpReceiveQueue::insertBytesFromSegment ( Packet *  tcpSegment, const Ptr< const TcpHeader > &  tcpHeader  )

virtual

Called when a TCP segment arrives, it should extract the payload from the segment and store it in the receive queue.

The segment object should not be deleted.

The method should return the sequence number to be ACKed.

{
    B tcpHeaderLength = tcpHeader->getHeaderLength();
    B tcpPayloadLength = tcpSegment->getDataLength() - tcpHeaderLength;
    uint32_t seq = tcpHeader->getSequenceNo();
    uint32_t offs = 0;
    uint32_t buffSeq = offsetToSeq(reorderBuffer.getExpectedOffset());
 
#ifndef NDEBUG
    if (!reorderBuffer.isEmpty()) {
        uint32_t ob = offsetToSeq(reorderBuffer.getRegionStartOffset(0));
        uint32_t oe = offsetToSeq(reorderBuffer.getRegionEndOffset(reorderBuffer.getNumRegions() - 1));
        uint32_t nb = seq;
        uint32_t ne = seq + tcpPayloadLength.get();
        uint32_t minb = seqMin(ob, nb);
        uint32_t maxe = seqMax(oe, ne);
        if (seqGE(minb, oe) || seqGE(minb, ne) || seqGE(ob, maxe) || seqGE(nb, maxe))
            throw cRuntimeError("The new segment is [%u, %u) out of the acceptable range at the queue %s",
                    nb, ne, str().c_str());
    }
#endif // ifndef NDEBUG
 
    if (seqLess(seq, buffSeq)) {
        offs = buffSeq - seq;
        seq = buffSeq;
        tcpPayloadLength -= B(offs);
    }
    const auto& payload = tcpSegment->peekDataAt(tcpHeaderLength + B(offs), tcpPayloadLength);
    reorderBuffer.replace(seqToOffset(seq), payload);
 
    if (seqGE(rcv_nxt, offsetToSeq(reorderBuffer.getRegionStartOffset(0))))
        rcv_nxt = offsetToSeq(reorderBuffer.getRegionStartOffset(0) + reorderBuffer.getRegionLength(0));
 
    return rcv_nxt;
}

Referenced by inet::tcp::TcpConnection::processSegment1stThru8th(), inet::tcp::TcpConnection::processSegmentInSynSent(), and inet::tcp::TcpConnection::processSynInListen().

offsetToSeq()

uint32_t inet::tcp::TcpReceiveQueue::offsetToSeq ( B  offs ) const

inlineprotected

{ return (uint32_t)offs.get(); }

Referenced by getFirstSeqNo(), getLE(), getRE(), insertBytesFromSegment(), and str().

seqToOffset()

B inet::tcp::TcpReceiveQueue::seqToOffset ( uint32_t  seq ) const

inlineprotected

    {
        B expOffs = reorderBuffer.getExpectedOffset();
        uint32_t expSeq = offsetToSeq(expOffs);
        return B((seqGE(seq, expSeq)) ? B(expOffs).get() + (seq - expSeq) : B(expOffs).get() - (expSeq - seq));
    }

Referenced by extractBytesUpTo(), getLE(), getRE(), and insertBytesFromSegment().

setConnection()

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

inlinevirtual

Set the connection that owns this queue.

{ conn = _conn; }

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

str()

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

overridevirtual

{
    std::ostringstream buf;
    buf << "rcv_nxt=" << rcv_nxt;
 
    for (int i = 0; i < reorderBuffer.getNumRegions(); i++) {
        buf << " [" << offsetToSeq(reorderBuffer.getRegionStartOffset(i)) << ".." << offsetToSeq(reorderBuffer.getRegionEndOffset(i)) << ")";
    }
    return buf.str();
}

Referenced by getQueueStatus(), and insertBytesFromSegment().

Member Data Documentation

conn

TcpConnection* inet::tcp::TcpReceiveQueue::conn = nullptr

protected

rcv_nxt

uint32_t inet::tcp::TcpReceiveQueue::rcv_nxt = 0

protected

Referenced by extractBytesUpTo(), getFirstSeqNo(), init(), insertBytesFromSegment(), and str().

reorderBuffer

ReorderBuffer inet::tcp::TcpReceiveQueue::reorderBuffer

protected

Referenced by extractBytesUpTo(), getAmountOfBufferedBytes(), getFirstSeqNo(), getLE(), getQueueLength(), getQueueStatus(), getRE(), init(), insertBytesFromSegment(), and str().

---

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

• TcpReceiveQueue.h
• TcpReceiveQueue.cc