inet::tcp::TcpWestwood Class Reference

#include <TcpWestwood.h>

Inheritance diagram for inet::tcp::TcpWestwood:

Public Member Functions
	TcpWestwood ()
	Ctor. More...
virtual void	receivedDataAck (uint32_t 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...
virtual void	dataSent (uint32_t fromseq) override
	Called after we send data. More...
virtual void	segmentRetransmitted (uint32_t fromseq, uint32_t toseq) override
	Called after we retransmitted segment. 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_t 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	restartRexmitTimer () override
	Restart REXMIT timer. More...
virtual bool	shouldMarkAck () override
	Called before sending ACK. More...
virtual void	processEcnInEstablished () override
	Called before processing segment in established state. 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 TCPvegasStateVariables object. More...
virtual void	recalculateSlowStartThreshold ()
	Utility function to recalculate ssthresh. More...
virtual void	processRexmitTimer (TcpEventCode &event) override
	Redefine what should happen on retransmission. More...
virtual void	recalculateBWE (uint32_t cumul_ack)
	Recalculate BWE. More...
Protected Member Functions inherited from inet::tcp::TcpBaseAlg
virtual void	processPersistTimer (TcpEventCode &event)
virtual void	processDelayedAckTimer (TcpEventCode &event)
virtual void	processKeepAliveTimer (TcpEventCode &event)
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_t echoedTS) override
	Converting uint32_t 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...

Protected Attributes
TcpWestwoodStateVariables *&	state
Protected Attributes inherited from inet::tcp::TcpBaseAlg
TcpBaseAlgStateVariables *&	state
cMessage *	rexmitTimer
cMessage *	persistTimer
cMessage *	delayedAckTimer
cMessage *	keepAliveTimer
Protected Attributes inherited from inet::tcp::TcpAlgorithm
TcpConnection *	conn
TcpStateVariables *	state

Additional Inherited Members
Static Protected Attributes inherited from inet::tcp::TcpBaseAlg
static simsignal_t	cwndSignal = cComponent::registerSignal("cwnd")
static simsignal_t	ssthreshSignal = cComponent::registerSignal("ssthresh")
static simsignal_t	rttSignal = cComponent::registerSignal("rtt")
static simsignal_t	srttSignal = cComponent::registerSignal("srtt")
static simsignal_t	rttvarSignal = cComponent::registerSignal("rttvar")
static simsignal_t	rtoSignal = cComponent::registerSignal("rto")
static simsignal_t	numRtosSignal = cComponent::registerSignal("numRtos")

Constructor & Destructor Documentation

TcpWestwood()

inet::tcp::TcpWestwood::TcpWestwood

(

)

Ctor.

    : TcpBaseAlg(), state((TcpWestwoodStateVariables *&)TcpAlgorithm::state)
{
}

Member Function Documentation

createStateVariables()

virtual TcpStateVariables* inet::tcp::TcpWestwood::createStateVariables ( )

inlineoverrideprotectedvirtual

Create and return a TCPvegasStateVariables object.

Implements inet::tcp::TcpAlgorithm.

    {
        return new TcpWestwoodStateVariables();
    }

dataSent()

void inet::tcp::TcpWestwood::dataSent ( uint32_t  fromseq )

overridevirtual

Called after we send data.

Reimplemented from inet::tcp::TcpBaseAlg.

{
    TcpBaseAlg::dataSent(fromseq);
 
    // save time when packet is sent
    // fromseq is the seq number of the 1st sent byte
 
    simtime_t sendtime = simTime();
    state->regions.clearTo(state->snd_una);
    state->regions.set(fromseq, state->snd_max, sendtime);
}

processRexmitTimer()

void inet::tcp::TcpWestwood::processRexmitTimer ( TcpEventCode &  event )

overrideprotectedvirtual

Redefine what should happen on retransmission.

Reimplemented from inet::tcp::TcpBaseAlg.

{
    TcpBaseAlg::processRexmitTimer(event);
 
    if (event == TCP_E_ABORT)
        return;
 
    // TCP Westwood: congestion control with faster recovery. S. Mascolo, C. Casetti, M. Gerla, S.S. Lee, M. Sanadidi
    // After REXMIT timeout in TCP Westwood: a increases from 1 to 4, in steps of 1 during slow start,
    // and is set to 1 in cong. avoidance.
    // the cong. window is reset to 1 after a timeout, as is done by TCP Reno. Conservative. Reaseon: fairness.
 
    if (state->snd_cwnd < state->ssthresh) { // Slow start
        state->w_a = state->w_a + 1;
        if (state->w_a > 4)
            state->w_a = 4;
    }
    else { // Cong. avoidance
        state->w_a = 1;
    }
 
    recalculateSlowStartThreshold();
    if (state->ssthresh < 2 * state->snd_mss)
        state->ssthresh = 2 * state->snd_mss;
 
    state->snd_cwnd = state->snd_mss;
 
    conn->emit(cwndSignal, state->snd_cwnd);
 
    state->afterRto = true;
    conn->retransmitOneSegment(true);
}

recalculateBWE()

void inet::tcp::TcpWestwood::recalculateBWE ( uint32_t  cumul_ack )

protectedvirtual

Recalculate BWE.

{
    simtime_t currentTime = simTime();
    simtime_t timeAck = currentTime - state->w_lastAckTime;
 
    // Update BWE
    if (timeAck > 0) {
        double old_sample_bwe = state->w_sample_bwe;
        double old_bwe = state->w_bwe;
        state->w_sample_bwe = (cumul_ack) / timeAck;
        state->w_bwe = (19.0 / 21.0) * old_bwe + (1.0 / 21.0) * (state->w_sample_bwe + old_sample_bwe);
        EV_DEBUG << "recalculateBWE(), new w_bwe=" << state->w_bwe << "\n";
    }
    state->w_lastAckTime = currentTime;
}

Referenced by receivedDataAck(), and receivedDuplicateAck().

recalculateSlowStartThreshold()

void inet::tcp::TcpWestwood::recalculateSlowStartThreshold ( )

protectedvirtual

Utility function to recalculate ssthresh.

{
    state->ssthresh = (uint32_t)((state->w_bwe * SIMTIME_DBL(state->w_RTTmin)) / (state->w_a));
 
    conn->emit(ssthreshSignal, state->ssthresh);
 
    EV_DEBUG << "recalculateSlowStartThreshold(), ssthresh=" << state->ssthresh << "\n";
}

Referenced by processRexmitTimer(), and receivedDuplicateAck().

receivedDataAck()

void inet::tcp::TcpWestwood::receivedDataAck ( uint32_t  firstSeqAcked )

overridevirtual

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

Reimplemented from inet::tcp::TcpBaseAlg.

{
    TcpBaseAlg::receivedDataAck(firstSeqAcked);
 
    state->regions.clearTo(state->snd_una);
    const TcpSegmentTransmitInfoList::Item *found = state->regions.get(firstSeqAcked);
 
    if (found != nullptr) {
        simtime_t currentTime = simTime();
        simtime_t newRTT = currentTime - found->getFirstSentTime();
 
        // Update RTTmin
        if (newRTT < state->w_RTTmin && newRTT > 0 && found->getTransmitCount() == 1)
            state->w_RTTmin = newRTT;
 
        // cumul_ack: cumulative ack's that acks 2 or more pkts count 1,
        // because DUPACKs count them
        uint32_t cumul_ack = state->snd_una - firstSeqAcked; // acked bytes
        if ((state->dupacks * state->snd_mss) >= cumul_ack)
            cumul_ack = state->snd_mss; // cumul_ack = 1:
        else
            cumul_ack -= (state->dupacks * state->snd_mss);
 
        // security check: if previous steps are right cumul_ack shoudl be > 2:
        if (cumul_ack > (2 * state->snd_mss))
            cumul_ack = 2 * state->snd_mss;
 
        recalculateBWE(cumul_ack);
    } // Closes if w_sendtime != nullptr
 
    // Same behavior of Reno during fast recovery, slow start and cong. avoidance
 
    if (state->dupacks >= state->dupthresh) {
        //
        // Perform Fast Recovery: set cwnd to ssthresh (deflating the window).
        //
        EV_DETAIL << "Fast Recovery: setting cwnd to ssthresh=" << state->ssthresh << "\n";
        state->snd_cwnd = state->ssthresh;
 
        conn->emit(cwndSignal, state->snd_cwnd);
    }
    else {
        //
        // Perform slow start and congestion avoidance.
        //
        if (state->snd_cwnd < state->ssthresh) {
            EV_DETAIL << "cwnd <= ssthresh: Slow Start: increasing cwnd by one 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. This RFC is experimental and probably not
            // implemented in real-life TCPs, hence it's commented out. Also, the ABC
            // RFC would require other modifications as well in addition to the
            // two lines below.
            //
//            int bytesAcked = state->snd_una - firstSeqAcked;
//            state->snd_cwnd += bytesAcked * state->snd_mss;
 
            conn->emit(cwndSignal, state->snd_cwnd);
 
            EV_DETAIL << "cwnd=" << state->snd_cwnd << "\n";
        }
        else {
            // perform Congestion Avoidance (RFC 2581)
            uint32_t incr = state->snd_mss * state->snd_mss / state->snd_cwnd;
 
            if (incr == 0)
                incr = 1;
 
            state->snd_cwnd += incr;
 
            conn->emit(cwndSignal, 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";
        }
    }
 
    sendData(false);
}

receivedDuplicateAck()

void inet::tcp::TcpWestwood::receivedDuplicateAck ( )

overridevirtual

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

Reimplemented from inet::tcp::TcpBaseAlg.

{
    TcpBaseAlg::receivedDuplicateAck();
 
    {
        // BWE calculation: dupack counts 1
        uint32_t cumul_ack = state->snd_mss;
        recalculateBWE(cumul_ack);
    } // Closes if w_sendtime != nullptr
 
    if (state->dupacks == state->dupthresh) {
        EV_DETAIL << "Westwood on dupAcks == DUPTHRESH(=" << state->dupthresh << ": Faster Retransmit \n";
 
        // TCP Westwood: congestion control with faster recovery. S. Mascolo, C. Casetti, M. Gerla, S.S. Lee, M. Sanadidi
        // During the cong. avoidance phase we are probing for extra available bandwidth.
        // Therefore, when n DUPACKS are received, it means that we have hit the network
        // capacity. Thus, the slow start threshold is set equal to the available pipe size
        // (BWE*RTTmin), the cong. window is set equal to ssthresh and the cong. avoidance phase
        // is entered again to gently probe for new available bandwitdh.
 
        // During the slow start phase we are still probing for the available bandwidth.
        // Therefore the BWE we obtain after n duplicate ACKs is used to set the slow start threshold.
        // After ssthresh has been set, the cong. window is set equal to the slow start theshold only
        // if cwin>ssthresh. In other words, during slow start, cwin still features an exponential
        // increase as in the current implementation of TCP Reno.
 
        // a increases from 1 to 4 in steps of 0.25 every time 3 DUPACKS are received in slow start.
        // while is set to 1 in cong. avoidance. (is initialized as 1).
        // The purpose of the theshold reduction factor a is to dampen a possible overestimation of
        // the available bandwidth. the more frequently a triple DUPACK is received during slow start,
        // the bigger the reduction factor becomes.
        // a is restored to 1 in cong. avoidance: ssthresh was set correctly and there is no need to reduce
        // the impact of BWE
 
        if (state->snd_cwnd < state->ssthresh) { // Slow start
            state->w_a = state->w_a + 0.25;
            if (state->w_a > 4)
                state->w_a = 4;
        }
        else { // Cong. avoidance
            state->w_a = 1;
        }
 
        recalculateSlowStartThreshold();
        // reset cwnd to ssthresh, if larger
        if (state->snd_cwnd > state->ssthresh)
            state->snd_cwnd = state->ssthresh;
 
        conn->emit(cwndSignal, 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
        restartRexmitTimer();
        conn->retransmitOneSegment(false);
 
        sendData(false);
    }
    // Behavior like Reno:
    else if (state->dupacks > state->dupthresh) {
        // Westwood: like Reno
        state->snd_cwnd += state->snd_mss;
        EV_DETAIL << "Westwood on dupAcks > DUPTHRESH(=" << state->dupthresh << ": Fast Recovery: inflating cwnd by SMSS, new cwnd=" << state->snd_cwnd << "\n";
 
        conn->emit(cwndSignal, state->snd_cwnd);
 
        sendData(false);
    }
}

segmentRetransmitted()

void inet::tcp::TcpWestwood::segmentRetransmitted ( uint32_t  fromseq, uint32_t  toseq  )

overridevirtual

Called after we retransmitted segment.

The argument fromseq is the seqno of the first byte sent. The argument toseq is the seqno of the last byte sent+1.

Reimplemented from inet::tcp::TcpBaseAlg.

{
    TcpBaseAlg::segmentRetransmitted(fromseq, toseq);
 
    state->regions.set(fromseq, toseq, simTime());
}

Member Data Documentation

state

TcpWestwoodStateVariables*& inet::tcp::TcpWestwood::state

protected

Referenced by dataSent(), processRexmitTimer(), recalculateBWE(), recalculateSlowStartThreshold(), receivedDataAck(), receivedDuplicateAck(), and segmentRetransmitted().

---

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

• TcpWestwood.h
• TcpWestwood.cc