tcp-rfc793edu.cc

Go to the documentation of this file.

/*
 * Copyright (c) 1999  International Computer Science Institute
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by ACIRI, the AT&T
 *      Center for Internet Research at ICSI (the International Computer
 *      Science Institute).
 * 4. Neither the name of ACIRI nor of ICSI may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ICSI AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL ICSI OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <math.h>


#include "ip.h"
#include "tcp-rfc793edu.h"
#include "flags.h"

// Original code contributed by Fernando Cela Diaz,
// <fcela@ce.chalmers.se>.
// For more information, see the following:
// URL "http://www.ce.chalmers.se/~fcela/tcp-tour.html"

static class  RFC793eduTcpClass : public TclClass {
public:
        RFC793eduTcpClass() : TclClass("Agent/TCP/RFC793edu") {}
        TclObject* create(int, const char*const*) {
                return (new RFC793eduTcpAgent());
        }
} class_rfc793edu;


RFC793eduTcpAgent::RFC793eduTcpAgent() : TcpAgent() 
{
}

void
RFC793eduTcpAgent::delay_bind_init_all()
{
        delay_bind_init_one("add793expbackoff_");
        delay_bind_init_one("add793jacobsonrtt_");
        delay_bind_init_one("add793fastrtx_");
        delay_bind_init_one("add793slowstart_");
        delay_bind_init_one("add793additiveinc_");
        delay_bind_init_one("add793karnrtt_");
        delay_bind_init_one("add793exponinc_"); 
        delay_bind_init_one("rto_");
        TcpAgent::delay_bind_init_all();
        reset();
}

int
RFC793eduTcpAgent::delay_bind_dispatch(const char *varName, 
                                       const char *localName,TclObject *tracer)
{
        if (delay_bind_bool(varName, localName, "add793expbackoff_", 
                            &add793expbackoff_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793jacobsonrtt_", 
                            &add793jacobsonrtt_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793fastrtx_", 
                            &add793fastrtx_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793slowstart_", 
                            &add793slowstart_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793slowstart_", 
                            &add793slowstart_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793additiveinc_", 
                            &add793additiveinc_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793karnrtt_", 
                            &add793karnrtt_, tracer)) 
                return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793exponinc_", 
                            &add793exponinc_, tracer)) 
                return TCL_OK;
        if (delay_bind(varName, localName, "rto_", 
                       &rto_, tracer)) 
                return TCL_OK;
        return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
}

void RFC793eduTcpAgent::reset()
{
  //Reset here protected vars. 

  rto_ = rtxcur_init_ / tcp_tick_;
  TcpAgent::reset();
}


void RFC793eduTcpAgent::rtt_update(double tao)
{
  double now = Scheduler::instance().clock();
  if (ts_option_)
    t_rtt_ = int(tao /tcp_tick_ + 0.5);
  else {
    double sendtime = now - tao;
    sendtime += boot_time_;
    double tickoff = fmod(sendtime, tcp_tick_);
    t_rtt_ = int((tao + tickoff) / tcp_tick_);
  }
  if (t_rtt_ < 1)
    t_rtt_ = 1;
  
      // Jacobson/Karels RTT estimation as implemented in tcp.cc
      //
      // Diference    = SampleRTT - EstimatedRTT
      // EstimatedRTT = EstimatedRTT + (delta * Difference)
      // Deviation    = Deviation + delta * (|Difference| - Deviation)
      // TimeOut      = EstimatedRTT + 4 * Deviation

      // srtt has 3 bits to the right of the binary point
      // rttvar has 2
      if (t_srtt_ != 0) {
        register short delta;
        delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS);      // d = (m - a0)
        if ((t_srtt_ += delta) <= 0)    // a1 = 7/8 a0 + 1/8 m
          t_srtt_ = 1;
        if (delta < 0)
          delta = -delta;
        delta -= (t_rttvar_ >> T_RTTVAR_BITS);
        if ((t_rttvar_ += delta) <= 0)  // var1 = 3/4 var0 + 1/4 |d|
          t_rttvar_ = 1;
      } else {
        t_srtt_ = t_rtt_ << T_SRTT_BITS;                // srtt = rtt
        t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1);        // rttvar = rtt / 2
      }

   if (add793jacobsonrtt_) 
    {
      //
      // Current retransmit value is 
      //    (unscaled) smoothed round trip estimate
      //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
      //
      rto_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS)))                   + t_srtt_)  >> T_SRTT_BITS );
    }
   else { 
     // RFC 793
     rto_ = (t_srtt_ >> ( T_SRTT_BITS - 1) );
   }
      t_rtxcur_ = rto_  * tcp_tick_;
  return;
}


void RFC793eduTcpAgent::rtt_backoff()
{
  if (add793expbackoff_) {
    // Standard Tahoe Code

        if (t_backoff_ < 64)
                t_backoff_ <<= 1;

        if (t_backoff_ > 8) {
                /*
                 * If backed off this far, clobber the srtt
                 * value, storing it in the mean deviation
                 * instead.
                 */
                t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);
                t_srtt_ = 0;
        }
  }
  // safe paranoia
  else 
    t_backoff_ = 1;
}


void RFC793eduTcpAgent::recv(Packet *pkt, Handler*)
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
#ifdef notdef
        if (pkt->type_ != PT_ACK) {
                Tcl::instance().evalf("%s error \"received non-ack\"",
                                      name());
                Packet::free(pkt);
                return;
        }
#endif
        ++nackpack_;
        ts_peer_ = tcph->ts();
        int ecnecho = hdr_flags::access(pkt)->ecnecho();
        if (ecnecho && ecn_)
                ecn(tcph->seqno());
        recv_helper(pkt);
        /* grow cwnd and check if the connection is done */ 
        if (tcph->seqno() > last_ack_) {
                recv_newack_helper(pkt);
                if (last_ack_ == 0 && delay_growth_) { 
                        cwnd_ = initial_window();
                }
        } else if (tcph->seqno() == last_ack_) {
                if (hdr_flags::access(pkt)->eln_ && eln_) {
                        tcp_eln(pkt);
                        return;
                }
                // fast retransmission
                if ( (++dupacks_ == numdupacks_) && add793fastrtx_ ) {
                        dupack_action();
                }
        }
        Packet::free(pkt);
        /*
         * Try to send more data.
         */
        send_much(0, 0, maxburst_);
}



void RFC793eduTcpAgent::opencwnd()
{
        if ( !(add793slowstart_ || add793exponinc_ || add793additiveinc_)) {
          cwnd_ = wnd_;
        } else if (((cwnd_ < ssthresh_) && (!add793additiveinc_)) 
                   || add793exponinc_)
          {
                /* slow-start (exponential) */
                if (add793exponinc_ && (cwnd_ < ssthresh_))
                  cwnd_ = ssthresh_;
                else cwnd_ += 1;
        } else {
                /* linear */
                double f;

                if (add793additiveinc_ && (cwnd_ < ssthresh_))
                  cwnd_ = ssthresh_;
                else {
                  switch (wnd_option_) {
                  case 0:
                    if (++count_ >= cwnd_) {
                      count_ = 0;
                      ++cwnd_;
                    }
                    break;
                    
                  case 1:
                        /* This is the standard algorithm. */
                    cwnd_ += 1 / cwnd_;
                    break;
                    
                  case 2:
                    /* These are window increase algorithms
                     * for experimental purposes only. */
                    f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
                    f *= f;
                    f *= wnd_const_;
                    f += fcnt_;
                    if (f > cwnd_) {
                      fcnt_ = 0;
                      ++cwnd_;
                    } else
                      fcnt_ = f;
                    break;
                        
                  case 3:
                    f = awnd_;
                    f *= f;
                    f *= wnd_const_;
                    f += fcnt_;
                    if (f > cwnd_) {
                      fcnt_ = 0;
                      ++cwnd_;
                    } else
                      fcnt_ = f;
                    break;
                    
                  case 4:
                    f = awnd_;
                    f *= wnd_const_;
                    f += fcnt_;
                    if (f > cwnd_) {
                      fcnt_ = 0;
                      ++cwnd_;
                    } else
                                fcnt_ = f;
                    break;
                  case 5:
                    f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
                    f *= wnd_const_;
                    f += fcnt_;
                    if (f > cwnd_) {
                      fcnt_ = 0;
                      ++cwnd_;
                    } else
                      fcnt_ = f;
                    break;
                    
                  default:
#ifdef notdef
                    /*XXX*/
                    error("illegal window option %d", wnd_option_);
#endif
                    abort();
                  }
                }
        }
        // if maxcwnd_ is set (nonzero), make it the cwnd limit
        if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
          cwnd_ = maxcwnd_;
        
        return;
}


void  RFC793eduTcpAgent::output(int seqno, int reason)
{
        int force_set_rtx_timer = 0;
        Packet* p = allocpkt();
        hdr_tcp *tcph = hdr_tcp::access(p);
        hdr_flags* hf = hdr_flags::access(p);
        tcph->seqno() = seqno;
        tcph->ts() = Scheduler::instance().clock();
        tcph->ts_echo() = ts_peer_;
        tcph->reason() = reason;
        if (ecn_) {
                hf->ect() = 1;  // ECN-capable transport
        }
        if (cong_action_) {
                hf->cong_action() = TRUE;  // Congestion action.
                cong_action_ = FALSE;
        }
        /* Check if this is the initial SYN packet. */
        if (seqno == 0) {
                if (syn_) {
                        hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;
                }
                if (ecn_) {
                        hf->ecnecho() = 1;
//                      hf->cong_action() = 1;
                        hf->ect() = 0;
                }
        }
        int bytes = hdr_cmn::access(p)->size();

        /* if no outstanding data, be sure to set rtx timer again */
        if (highest_ack_ == maxseq_)
                force_set_rtx_timer = 1;
        /* call helper function to fill in additional fields */
        output_helper(p);

        ++ndatapack_;
        ndatabytes_ += bytes;
        send(p, 0);
        if (seqno == curseq_ && seqno > maxseq_)
                idle();  // Tell application I have sent everything so far
        if (seqno > maxseq_) {
                maxseq_ = seqno;
                if (!rtt_active_) {
                        rtt_active_ = 1;                        
                        if (seqno > rtt_seq_) {
                                rtt_seq_ = seqno;                       
                                rtt_ts_ = Scheduler::instance().clock();
                        }
                                        
                }
        } else {
          if (!add793karnrtt_) {
                rtt_active_ = 1;
                rtt_seq_ = seqno;                       
                rtt_ts_ = Scheduler::instance().clock();
          }     
                ++nrexmitpack_;
                nrexmitbytes_ += bytes;
        }
        if (!(rtx_timer_.status() == TIMER_PENDING) || force_set_rtx_timer)
                /* No timer pending.  Schedule one. */
                set_rtx_timer();
}

void RFC793eduTcpAgent::recv_newack_helper(Packet *pkt) {
        //hdr_tcp *tcph = hdr_tcp::access(pkt);
        newack(pkt);
        if (!ect_ || !hdr_flags::access(pkt)->ecnecho() ||
                (old_ecn_ && ecn_burst_)) 
                /* If "old_ecn", this is not the first ACK carrying ECN-Echo
                 * after a period of ACKs without ECN-Echo.
                 * Therefore, open the congestion window. */
                opencwnd();
        if (ect_) {
                if (!hdr_flags::access(pkt)->ecnecho())
                        ecn_backoff_ = 0;
                if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho())
                        ecn_burst_ = TRUE;
                else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho())
                        ecn_burst_ = FALSE;
        }
        if (!ect_ && hdr_flags::access(pkt)->ecnecho() &&
                !hdr_flags::access(pkt)->cong_action())
                ect_ = 1;
        /* if the connection is done, call finish() */
        if ((highest_ack_ >= curseq_-1) && !closed_) {
                closed_ = 1;
                finish();
        }
}

void RFC793eduTcpAgent::newack(Packet* pkt)
{
        double now = Scheduler::instance().clock();
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        /* 
         * Wouldn't it be better to set the timer *after*
         * updating the RTT, instead of *before*? 
         */
        newtimer(pkt);
        dupacks_ = 0;
        last_ack_ = tcph->seqno();
        highest_ack_ = last_ack_;

        if (t_seqno_ < last_ack_ + 1)
                t_seqno_ = last_ack_ + 1;
        /* 
         * Update RTT only if it's OK to do so from info in the flags header.
         * This is needed for protocols in which intermediate agents
         * in the network intersperse acks (e.g., ack-reconstructors) for
         * various reasons (without violating e2e semantics).
         */     
        hdr_flags *fh = hdr_flags::access(pkt);
        if (!fh->no_ts_) {
                if (ts_option_)
                        rtt_update(now - tcph->ts_echo());

                if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
                        if (!ect_ || !ecn_backoff_ || 
                                !hdr_flags::access(pkt)->ecnecho()) {
                                /* 
                                 * Don't end backoff if still in ECN-Echo with
                                 * a congestion window of 1 packet. 
                                 */
                                t_backoff_ = 1;
                                ecn_backoff_ = 0;
                        }
                        rtt_active_ = 0;
                        if (!ts_option_)
                                rtt_update(now - rtt_ts_);
                }
        }
        /* update average window */
        awnd_ *= 1.0 - wnd_th_;
        awnd_ += wnd_th_ * cwnd_;
}

        

---