inet::tcp::TCPTahoe Class Reference

Implements Tahoe. More...

#include <TCPTahoe.h>

Inheritance diagram for inet::tcp::TCPTahoe:

Public Member Functions
	TCPTahoe ()
	Ctor. More...
virtual void	receivedDataAck (uint32 firstSeqAcked) override
	Redefine what should happen when data got acked, to add congestion window management. More...
virtual void	receivedDuplicateAck () override
	Redefine what should happen when dupAck was received, to add congestion window management. More...
Public Member Functions inherited from inet::tcp::TCPTahoeRenoFamily
	TCPTahoeRenoFamily ()
	Ctor. More...
Public Member Functions inherited from inet::tcp::TCPBaseAlg
	TCPBaseAlg ()
	Ctor. More...
virtual	~TCPBaseAlg ()
	Virtual dtor. More...
virtual void	initialize () override
	Create timers, etc. More...
virtual void	established (bool active) override
	Called when the connection is going to ESTABLISHED from SYN_SENT or SYN_RCVD. More...
virtual void	connectionClosed () override
	Called when the connection closes, it should cancel all running timers. More...
virtual void	processTimer (cMessage *timer, TCPEventCode &event) override
	Process REXMIT, PERSIST, DELAYED-ACK and KEEP-ALIVE timers. More...
virtual void	sendCommandInvoked () override
	Called after user sent TCP_C_SEND command to us. More...
virtual void	receivedOutOfOrderSegment () override
	Called after receiving data which are in the window, but not at its left edge (seq != rcv_nxt). More...
virtual void	receiveSeqChanged () override
	Called after rcv_nxt got advanced, either because we received in-sequence data ("text" in RFC 793 lingo) or a FIN. More...
virtual void	receivedAckForDataNotYetSent (uint32 seq) override
	Called after we received an ACK for data not yet sent. More...
virtual void	ackSent () override
	Called after we sent an ACK. More...
virtual void	dataSent (uint32 fromseq) override
	Called after we sent data. More...
virtual void	segmentRetransmitted (uint32 fromseq, uint32 toseq) override
	Called after we retransmitted segment. More...
virtual void	restartRexmitTimer () override
	Restart REXMIT timer. More...
Public Member Functions inherited from inet::tcp::TCPAlgorithm
	TCPAlgorithm ()
	Ctor. More...
virtual	~TCPAlgorithm ()
	Virtual dtor. More...
void	setConnection (TCPConnection *_conn)
	Assign this object to a TCPConnection. More...
TCPStateVariables *	getStateVariables ()
	Creates and returns the TCP state variables. More...

Protected Member Functions
virtual TCPStateVariables *	createStateVariables () override
	Create and return a TCPTahoeStateVariables object. More...
virtual void	recalculateSlowStartThreshold ()
	Utility function to recalculate ssthresh. More...
virtual void	processRexmitTimer (TCPEventCode &event) override
	Redefine what should happen on retransmission. More...
Protected Member Functions inherited from inet::tcp::TCPBaseAlg
virtual void	startRexmitTimer ()
	Start REXMIT timer and initialize retransmission variables. More...
virtual void	rttMeasurementComplete (simtime_t tSent, simtime_t tAcked)
	Update state vars with new measured RTT value. More...
virtual void	rttMeasurementCompleteUsingTS (uint32 echoedTS) override
	Converting uint32 echoedTS to simtime_t and calling rttMeasurementComplete() to update state vars with new measured RTT value. More...
virtual bool	sendData (bool sendCommandInvoked)
	Send data, observing Nagle's algorithm and congestion window. More...
cMessage *	cancelEvent (cMessage *msg)
	Utility function. More...
virtual void	processPersistTimer (TCPEventCode &event)
virtual void	processDelayedAckTimer (TCPEventCode &event)
virtual void	processKeepAliveTimer (TCPEventCode &event)

Protected Attributes
TCPTahoeStateVariables *&	state
Protected Attributes inherited from inet::tcp::TCPTahoeRenoFamily
TCPTahoeRenoFamilyStateVariables *&	state
Protected Attributes inherited from inet::tcp::TCPBaseAlg
TCPBaseAlgStateVariables *&	state
cMessage *	rexmitTimer
cMessage *	persistTimer
cMessage *	delayedAckTimer
cMessage *	keepAliveTimer
cOutVector *	cwndVector
cOutVector *	ssthreshVector
cOutVector *	rttVector
cOutVector *	srttVector
cOutVector *	rttvarVector
cOutVector *	rtoVector
cOutVector *	numRtosVector
Protected Attributes inherited from inet::tcp::TCPAlgorithm
TCPConnection *	conn
TCPStateVariables *	state

Detailed Description

Implements Tahoe.

Constructor & Destructor Documentation

inet::tcp::TCPTahoe::TCPTahoe

(

)

Ctor.

                   : TCPTahoeRenoFamily(),
    state((TCPTahoeStateVariables *&)TCPAlgorithm::state)
{
}

Member Function Documentation

virtual TCPStateVariables* inet::tcp::TCPTahoe::createStateVariables ( )

inlineoverrideprotectedvirtual

Create and return a TCPTahoeStateVariables object.

Implements inet::tcp::TCPAlgorithm.

    {
        return new TCPTahoeStateVariables();
    }

void inet::tcp::TCPTahoe::processRexmitTimer ( TCPEventCode &  event )

overrideprotectedvirtual

Redefine what should happen on retransmission.

Reimplemented from inet::tcp::TCPBaseAlg.

{
    TCPTahoeRenoFamily::processRexmitTimer(event);

    if (event == TCP_E_ABORT)
        return;

    // begin Slow Start (RFC 2581)
    recalculateSlowStartThreshold();
    state->snd_cwnd = state->snd_mss;

    if (cwndVector)
        cwndVector->record(state->snd_cwnd);

    EV_INFO << "Begin Slow Start: resetting cwnd to " << state->snd_cwnd
            << ", ssthresh=" << state->ssthresh << "\n";

    state->afterRto = true;

    // Tahoe retransmits only one segment at the front of the queue
    conn->retransmitOneSegment(true);
}

void inet::tcp::TCPTahoe::recalculateSlowStartThreshold ( )

protectedvirtual

Utility function to recalculate ssthresh.

Referenced by processRexmitTimer(), and receivedDuplicateAck().

{
    // set ssthresh to flight size / 2, but at least 2 MSS
    // (the formula below practically amounts to ssthresh = cwnd / 2 most of the time)
    uint32 flight_size = std::min(state->snd_cwnd, state->snd_wnd);    // FIXME TODO - Does this formula computes the amount of outstanding data?
    // uint32 flight_size = state->snd_max - state->snd_una;
    state->ssthresh = std::max(flight_size / 2, 2 * state->snd_mss);

    if (ssthreshVector)
        ssthreshVector->record(state->ssthresh);
}

void inet::tcp::TCPTahoe::receivedDataAck ( uint32  firstSeqAcked )

overridevirtual

Redefine what should happen when data got acked, to add congestion window management.

Reimplemented from inet::tcp::TCPBaseAlg.

{
    TCPTahoeRenoFamily::receivedDataAck(firstSeqAcked);

    //
    // Perform slow start and congestion avoidance.
    //
    if (state->snd_cwnd < state->ssthresh) {
        EV_DETAIL << "cwnd <= ssthresh: Slow Start: increasing cwnd by SMSS bytes to ";

        // perform Slow Start. RFC 2581: "During slow start, a TCP increments cwnd
        // by at most SMSS bytes for each ACK received that acknowledges new data."
        state->snd_cwnd += state->snd_mss;

        // Note: we could increase cwnd based on the number of bytes being
        // acknowledged by each arriving ACK, rather than by the number of ACKs
        // that arrive. This is called "Appropriate Byte Counting" (ABC) and is
        // described in RFC 3465 (experimental).
        //
        // int bytesAcked = state->snd_una - firstSeqAcked;
        // state->snd_cwnd += bytesAcked;

        if (cwndVector)
            cwndVector->record(state->snd_cwnd);

        EV_DETAIL << "cwnd=" << state->snd_cwnd << "\n";
    }
    else {
        // perform Congestion Avoidance (RFC 2581)
        int incr = state->snd_mss * state->snd_mss / state->snd_cwnd;

        if (incr == 0)
            incr = 1;

        state->snd_cwnd += incr;

        if (cwndVector)
            cwndVector->record(state->snd_cwnd);

        //
        // Note: some implementations use extra additive constant mss / 8 here
        // which is known to be incorrect (RFC 2581 p5)
        //
        // Note 2: RFC 3465 (experimental) "Appropriate Byte Counting" (ABC)
        // would require maintaining a bytes_acked variable here which we don't do
        //

        EV_DETAIL << "cwnd>ssthresh: Congestion Avoidance: increasing cwnd linearly, to " << state->snd_cwnd << "\n";
    }

    // ack and/or cwnd increase may have freed up some room in the window, try sending
    sendData(false);
}

void inet::tcp::TCPTahoe::receivedDuplicateAck ( )

overridevirtual

Redefine what should happen when dupAck was received, to add congestion window management.

Reimplemented from inet::tcp::TCPBaseAlg.

{
    TCPTahoeRenoFamily::receivedDuplicateAck();

    if (state->dupacks == DUPTHRESH) {    // DUPTHRESH = 3
        EV_DETAIL << "Tahoe on dupAcks == DUPTHRESH(=3): perform Fast Retransmit, and enter Slow Start:\n";

        // enter Slow Start
        recalculateSlowStartThreshold();
        state->snd_cwnd = state->snd_mss;

        if (cwndVector)
            cwndVector->record(state->snd_cwnd);

        EV_DETAIL << "Set cwnd=" << state->snd_cwnd << ", ssthresh=" << state->ssthresh << "\n";

        // Fast Retransmission: retransmit missing segment without waiting
        // for the REXMIT timer to expire
        conn->retransmitOneSegment(false);

        // Do not restart REXMIT timer.
        // Note: Restart of REXMIT timer on retransmission is not part of RFC 2581, however optional in RFC 3517 if sent during recovery.
        // Resetting the REXMIT timer is discussed in RFC 2582/3782 (NewReno) and RFC 2988.
    }
}

Member Data Documentation

TCPTahoeStateVariables*& inet::tcp::TCPTahoe::state

protected

Referenced by processRexmitTimer(), recalculateSlowStartThreshold(), receivedDataAck(), and receivedDuplicateAck().

---

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

• TCPTahoe.h
• TCPTahoe.cc