tcp-asym-sink.cc

Go to the documentation of this file.

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * Copyright (c) 1997 Regents of the University of California.
 * 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 the Daedalus Research
 *      Group at the University of California Berkeley.
 * 4. Neither the name of the University nor of the Laboratory may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 THE REGENTS 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.
 *
 * Contributed by the Daedalus Research Group, U.C.Berkeley
 * http://daedalus.cs.berkeley.edu
 *
 * @(#) $Header: 
 */

/*
 * tcp-asym includes modifications to several flavors of TCP to enhance
 * performance over asymmetric networks, where the ack channel is
 * constrained.  Types of asymmetry we have studied and used these mods
 * include bandwidth asymmetry and latency asymmetry (where  variable 
 * latencies cause problems to TCP, e.g., in packet radio networks.
 * The receiver-side code in this file is derived from the regular
 * TCP sink code. The main additional functionality is that the sink responds
 * to ECN by performing ack congestion control, i.e. it multiplicatively backs
 * off the frequency with which it sends acks (up to a limit). For each 
 * subsequent round-trip period during which it does not receive an ECN, 
 * it gradually increases the frequency of acks (up to a maximum of 1 
 * per data packet).
 *
 * For questions/comments, please contact:
 *   Venkata N. Padmanabhan (padmanab@cs.berkeley.edu)
 *   http://www.cs.berkeley.edu/~padmanab
 */

#ifndef lint
static const char rcsid[] =
    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp/tcp-asym-sink.cc,v 1.16 1999/09/09 03:22:49 salehi Exp $ (UCB)";
#endif

#include "template.h"
#include "flags.h"
#include "tcp-sink.h"
#include "tcp-asym.h"


class TcpAsymSink : public DelAckSink {
public:
        TcpAsymSink(Acker*);
        virtual void recv(Packet* pkt, Handler* h);
        virtual void timeout(int tno);
protected:
        virtual void add_to_ack(Packet* pkt);
        int delackcount_;       /* the number of consecutive packets that have
                                   not been acked yet */
        int maxdelack_;         /* the maximum extent to which acks can be
                                   delayed */
        int delackfactor_;      /* the dynamically varying limit on the extent
                                   to which acks can be delayed */
        int delacklim_;         /* limit on the extent of del ack based on the
                                   sender's window */
        double ts_ecn_;         /* the time when an ECN was received last */
        double ts_decrease_;    /* the time when delackfactor_ was decreased last */
        double highest_ts_echo_;/* the highest timestamp echoed by the peer */
};      

static class TcpAsymSinkClass : public TclClass {
public:
        TcpAsymSinkClass() : TclClass("Agent/TCPSink/Asym") {}
        TclObject* create(int, const char*const*) {
                return (new TcpAsymSink(new Acker));
        }
} class_tcpasymsink;

TcpAsymSink::TcpAsymSink(Acker* acker) : DelAckSink(acker), delackcount_(0), 
    delackfactor_(1), delacklim_(0), ts_ecn_(0), ts_decrease_(0)
{
        bind("maxdelack_", &maxdelack_);
}

/* Add fields to the ack. Not needed? */
void TcpAsymSink::add_to_ack(Packet* pkt) 
{
        hdr_tcpasym *tha = hdr_tcpasym::access(pkt);
        tha->ackcount() = delackcount_;
}

void TcpAsymSink::recv(Packet* pkt, Handler*) 
{
        int olddelackfactor = delackfactor_;
        int olddelacklim = delacklim_; 
        int max_sender_can_send = 0;
        hdr_flags *fh = hdr_flags::access(pkt);
        hdr_tcp *th = hdr_tcp::access(pkt);
        hdr_tcpasym *tha = hdr_tcpasym::access(pkt);
        double now = Scheduler::instance().clock();
        int numBytes = hdr_cmn::access(pkt)->size();


        acker_->update_ts(th->seqno(),th->ts());
        acker_->update(th->seqno(), numBytes);

#if 0  // johnh
        int numToDeliver;
        /* XXX if the #if 0 is removed, delete the call to acker_->update() above */
        numToDeliver = acker_->update(th->seqno(), numBytes);
        if (numToDeliver)
                recvBytes(numToDeliver);
#endif /* 0 */

        /* determine the highest timestamp the sender has echoed */
        highest_ts_echo_ = max(highest_ts_echo_, th->ts_echo());
        /* 
         * if we receive an ECN and haven't received one in the past
         * round-trip, double delackfactor_ (and consequently halve
         * the frequency of acks) subject to a maximum
         */
        if (fh->ecnecho() && highest_ts_echo_ >= ts_ecn_) {
                delackfactor_ = min(2*delackfactor_, maxdelack_);
                ts_ecn_ = now;
        }
        /*
         * else if we haven't received an ECN in the past round trip and
         * haven't (linearly) decreased delackfactor_ in the past round
         * trip, we decrease delackfactor_ by 1 (and consequently increase
         * the frequency of acks) subject to a minimum
         */
        else if (highest_ts_echo_ >= ts_ecn_ && highest_ts_echo_ >= ts_decrease_) {
                delackfactor_ = max(delackfactor_ - 1, 1);
                ts_decrease_ = now;
        }

        /*
         * if this is the next packet in sequence, we can consider delaying the ack. 
         * Set delacklim_ based on how much data the sender can send if we don't
         * send back any more acks. The idea is to avoid stalling the sender because
         * of a lack of acks.
         */
        if (th->seqno() == acker_->Seqno()) {
                max_sender_can_send = (int) min(tha->win()+acker_->Seqno()-tha->highest_ack(), tha->max_left_to_send());
                /* XXXX we use a safety factor 2 */
                delacklim_ = min(maxdelack_, max_sender_can_send/2); 
        }
        else
                delacklim_ = 0;

        if (delackfactor_ < delacklim_) 
                delacklim_ = delackfactor_;

        /* 
         * Log values of variables of interest. Since this is the only place
         * where this is done, we decided against using a more general method
         * as used for logging TCP sender state variables.
         */
        if (channel_ && (olddelackfactor != delackfactor_ || olddelacklim != delacklim_)) {
                char wrk[500];
                int n;

                /* we print src and dst in reverse order to conform to sender side */
                sprintf(wrk, "time: %-6.3f saddr: %-2d sport: %-2d daddr:"
                        " %-2d dport: %-2d dafactor: %2d dalim: %2d max_scs:"
                        " %4d win: %4d\n", now, addr(), port(),
                        daddr(), dport(), delackfactor_,
                        delacklim_,max_sender_can_send, tha->win());  
                n = strlen(wrk);
                wrk[n] = '\n';
                wrk[n+1] = 0;
                (void)Tcl_Write(channel_, wrk, n+1);
                wrk[n] = 0;
        }
                
        delackcount_++;
        /* check if we have waited long enough that we should send an ack */
        if (delackcount_ < delacklim_) { /* it is not yet time to send an ack */
                /* if the delayed ack timer is not set, set it now */
                if (!(delay_timer_.status() == TIMER_PENDING)) {
                        save_ = pkt;
                        delay_timer_.resched(interval_);
                }
                else {
                        hdr_tcp *sth = hdr_tcp::access(save_);
                        /* save the pkt with the more recent timestamp */
                        if (th->ts() > sth->ts()) {
                                Packet::free(save_);
                                save_ = pkt;
                        }
                }
                return;
        }
        else { /* send back an ack now */
                if (delay_timer_.status() == TIMER_PENDING) {
                        delay_timer_.cancel();
                        Packet::free(save_);
                        save_ = 0;
                }
                hdr_flags* hf = hdr_flags::access(pkt);
                hf->ect() = 1;
                ack(pkt);
                delackcount_ = 0;
                Packet::free(pkt);
        }
}


void TcpAsymSink::timeout(int /*tno*/)
{
        /*
         * The timer expired so we ACK the last packet seen.
         */
        Packet* pkt = save_;
        delackcount_ = 0;
        ack(pkt);
        save_ = 0;
        Packet::free(pkt);
}

---