tcp-fs.cc

Go to the documentation of this file.

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * tcp-fs: TCP with "fast start", a procedure for avoiding the penalty of
 * slow start when a connection resumes after a pause. The connection tries
 * to reuse values old values of variables such as cwnd_, ssthresh_, srtt_,
 * etc., with suitable modifications. The same procedure as used in tcp-asym
 * is used to clock out packets until ack clocking kicks in. A connection 
 * doing fast start protects itself and other connections in the network against 
 * the adverse consequences of stale information by (a) marking all packets sent 
 * during fast start as low priority for the purposes of a priority-drop router, 
 * and (b) quickly detecting the loss of several fast start packets and falling 
 * back to a regular slow start, almost as if a fast start had never been attempted
 * in the first place.
 * 
 * Contributed by Venkat Padmanabhan (padmanab@cs.berkeley.edu), 
 * Daedalus Research Group, U.C.Berkeley
 */

#include "tcp-fs.h"

void ResetTimer::expire(Event *) {
        a_->timeout(TCP_TIMER_RESET);
}

static class TcpFsClass : public TclClass {
public:
        TcpFsClass() : TclClass("Agent/TCP/FS") {}
        TclObject* create(int, const char*const*) {
                return (new TcpFsAgent());
        }
} class_tcpfs;

static class RenoTcpFsClass : public TclClass {
public:
        RenoTcpFsClass() : TclClass("Agent/TCP/Reno/FS") {}
        TclObject* create(int, const char*const*) {
                return (new RenoTcpFsAgent());
        }
} class_renotcpfs;      

static class NewRenoTcpFsClass : public TclClass {
public:
        NewRenoTcpFsClass() : TclClass("Agent/TCP/Newreno/FS") {}
        TclObject* create(int, const char*const*) {
                return (new NewRenoTcpFsAgent());
        }
} class_newrenotcpfs;   

#ifdef USE_FACK
static class FackTcpFsClass : public TclClass {
public:
        FackTcpFsClass() : TclClass("Agent/TCP/Fack/FS") {}
        TclObject* create(int, const char*const*) {
                return (new FackTcpFsAgent());
        }
} class_facktcpfs;      
#endif


/* mark packets sent as part of fast start */
void
TcpFsAgent::output_helper(Packet *pkt)
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        double now = Scheduler::instance().clock();
        double idle_time = now - last_recv_time_;
        double timeout = ((t_srtt_ >> 3) + t_rttvar_) * tcp_tick_ ;
        maxseq_ = max(maxseq_, highest_ack_);

        /* 
         * if the connection has been idle (with no outstanding data) for long 
         * enough, we enter the fast start phase. We compute the start and end
         * sequence numbers that define the fast start phase. Note that the
         * first packet to be sent next is not included because it would have
         * been sent even with regular slow start.
         */
        if ((idle_time > timeout) && (maxseq_ == highest_ack_) && (cwnd_ > 1)){
                /*
                 * We set cwnd_ to a "safe" value: cwnd_/2 if the connection
                 * was in slow start before the start of the idle period and
                 * cwnd_-1 if it was in congestion avoidance phase.
                 */
/*              if (cwnd_ < ssthresh_+1)*/
                if (cwnd_ < ssthresh_)
                        cwnd_ = int(cwnd_/2);
                else
                        cwnd_ -= 1;
                /* set the start and end seq. nos. for the fast start phase */
                fs_startseq_ = highest_ack_+2;
                fs_endseq_ = highest_ack_+window()+1;
                fs_mode_ = 1;
        }
        /* initially set fs_ flag to 0 */
        hdr_flags::access(pkt)->fs_ = 0;
        /* check if packet belongs to the fast start phase. */
        if (tcph->seqno() >= fs_startseq_ && tcph->seqno() < fs_endseq_ && fs_mode_) {
                /* if not a retransmission, mark the packet */
                if (tcph->seqno() > maxseq_) {
                        hdr_flags::access(pkt)->fs_ = 1;
                }
        }
}

/* update last_output_time_ */
void
TcpFsAgent::recv_helper(Packet *) 
{
        double now = Scheduler::instance().clock();
        last_recv_time_ = now;
}

/* schedule the next burst of data (of size at most maxburst) */
void 
TcpFsAgent::send_helper(int maxburst) 
{
        /* 
         * If there is still data to be sent and there is space in the
         * window, set a timer to schedule the next burst. Note that
         * we wouldn't get here if TCP_TIMER_BURSTSEND were pending,
         * so we do not need an explicit check here.
         */
        if (t_seqno_ <= highest_ack_ + window() && t_seqno_ < curseq_) {
                burstsnd_timer_.resched(t_exact_srtt_*maxburst/window());
        }
}

#ifdef USE_FACK
/* schedule the next burst of data (of size at most maxburst) */
void 
FackTcpFsAgent::send_helper(int maxburst) 
{
        /* 
         * If there is still data to be sent and there is space in the
         * window, set a timer to schedule the next burst. Note that
         * we wouldn't get here if TCP_TIMER_BURSTSEND were pending,
         * so we do not need an explicit check here.
         */
        if ((t_seqno_ <= fack_ + window() - retran_data_) && (!timeout_) && (t_seqno_ < curseq_)) {
                burstsnd_timer_.resched(t_exact_srtt_*maxburst/window());
        }
}
#endif

/* do appropriate processing depending on the length of idle time */
void
TcpFsAgent::send_idle_helper() 
{
        // Commented out because they are not used
        // XXX What processing belong here??? - haoboy

        //double now = Scheduler::instance().clock();
        //double idle_time = now - last_recv_time_;
}

/* update srtt estimate */
void
TcpFsAgent::recv_newack_helper(Packet *pkt) 
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        double tao = Scheduler::instance().clock() - tcph->ts_echo();
        double g = 1/8; /* gain used for smoothing rtt */
        double h = 1/4; /* gain used for smoothing rttvar */
        double delta;
        int ackcount, i;

        /*
         * If we are counting the actual amount of data acked, ackcount >= 1.
         * Otherwise, ackcount=1 just as in standard TCP.
         */
        if (count_bytes_acked_)
                ackcount = tcph->seqno() - last_ack_;
        else
                ackcount = 1;
        newack(pkt);
        maxseq_ = max(maxseq_, highest_ack_);
        if (t_exact_srtt_ != 0) {
                delta = tao - t_exact_srtt_;
                if (delta < 0)
                        delta = -delta;
                /* update the fine-grained estimate of the smoothed RTT */
                if (t_exact_srtt_ != 0) 
                        t_exact_srtt_ = g*tao + (1-g)*t_exact_srtt_;
                else
                        t_exact_srtt_ = tao;
                /* update the fine-grained estimate of mean deviation in RTT */
                delta -= t_exact_rttvar_;
                t_exact_rttvar_ += h*delta;
        }
        else {
                t_exact_srtt_ = tao;
                t_exact_rttvar_ = tao/2;
        }
        /* grow cwnd. ackcount > 1 indicates that actual ack counting is enabled */
        for (i=0; i<ackcount; i++)
                opencwnd();
        /* check if we are out of fast start mode */
        if (fs_mode_ && (highest_ack_ >= fs_endseq_-1)) 
                fs_mode_ = 0;
        /* if the connection is done, call finish() */
        if ((highest_ack_ >= curseq_-1) && !closed_) {
                closed_ = 1;
                finish();
        }
}

void
NewRenoTcpFsAgent::partialnewack_helper(Packet* pkt)
{
        partialnewack(pkt);
        /* Do this because we may have retracted maxseq_ */
        maxseq_ = max(maxseq_, highest_ack_);
        if (fs_mode_ && fast_loss_recov_) {
                /* 
                 * A partial new ack implies that more than one packet has been lost
                 * in the window. Rather than recover one loss per RTT, we get out of
                 * fast start mode and do a slow start (no rtx timeout, though).
                 */
                timeout_nonrtx(TCP_TIMER_RESET);
        }
        else {
                output(last_ack_ + 1, 0);
        }
}

void 
TcpFsAgent::set_rtx_timer()
{
        if (rtx_timer_.status() == TIMER_PENDING)
                rtx_timer_.cancel();
        if (reset_timer_.status() == TIMER_PENDING)
                reset_timer_.cancel();
        if (fs_mode_ && fast_loss_recov_ && fast_reset_timer_)
                reset_timer_.resched(rtt_exact_timeout());
        else if (fs_mode_ && fast_loss_recov_)
                reset_timer_.resched(rtt_timeout());
        else 
                rtx_timer_.resched(rtt_timeout());
}

void 
TcpFsAgent::cancel_rtx_timer() 
{
        rtx_timer_.force_cancel();
        reset_timer_.force_cancel();
}

void 
TcpFsAgent::cancel_timers() 
{
        rtx_timer_.force_cancel();
        reset_timer_.force_cancel();
        burstsnd_timer_.force_cancel();
        delsnd_timer_.force_cancel();
}

void 
TcpFsAgent::timeout_nonrtx(int tno) 
{
        if (tno == TCP_TIMER_RESET) {
                fs_mode_ = 0;   /* out of fast start mode */
                dupacks_ = 0;   /* just to be safe */
                if (highest_ack_ == maxseq_ && !slow_start_restart_) {
                        /*
                         * TCP option:
                         * If no outstanding data, then don't do anything.
                         */
                        return;
                };
                /* 
                 * If the pkt sent just before the fast start phase has not
                 * gotten through, treat this as a regular rtx timeout.
                 */
                if (highest_ack_ < fs_startseq_-1) {
                        maxseq_ = fs_startseq_ - 1;
                        recover_ = maxseq_;
                        timeout(TCP_TIMER_RTX);
                }
                /* otherwise decrease window size to 1 but don't back off rtx timer */
                else {
                        if (highest_ack_ > last_ack_)
                                last_ack_ = highest_ack_;
                        maxseq_ = last_ack_;
                        recover_ = maxseq_;
                        last_cwnd_action_ = CWND_ACTION_TIMEOUT;
                        slowdown(CLOSE_CWND_INIT);
                        timeout_nonrtx_helper(tno);
                }
        }
        else {
                TcpAgent::timeout_nonrtx(tno);
        }
}

void 
TcpFsAgent::timeout_nonrtx_helper(int tno)
{
        if (tno == TCP_TIMER_RESET) {
                reset_rtx_timer(0,0);
                send_much(0, TCP_REASON_TIMEOUT, maxburst_);
        }
}

void 
RenoTcpFsAgent::timeout_nonrtx_helper(int tno)
{
        if (tno == TCP_TIMER_RESET) {
                dupwnd_ = 0;
                dupacks_ = 0;
                TcpFsAgent::timeout_nonrtx_helper(tno);
        }
}               

void 
NewRenoTcpFsAgent::timeout_nonrtx_helper(int tno)
{
        if (tno == TCP_TIMER_RESET) {
                dupwnd_ = 0;
                dupacks_ = 0;
                TcpFsAgent::timeout_nonrtx_helper(tno);
        }
}

#ifdef USE_FACK
void 
FackTcpFsAgent::timeout_nonrtx_helper(int tno)
{
        if (tno == TCP_TIMER_RESET) {
                timeout_ = FALSE;
                retran_data_ = 0;
                fack_ = last_ack_;
                t_seqno_ = last_ack_ + 1;
                reset_rtx_timer(TCP_REASON_TIMEOUT, 0);
                send_much(0, TCP_REASON_TIMEOUT);
        }
}
#endif

---