tcp-int.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 Research Group 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: /nfs/jade/vint/CVSROOT/ns-2/tcp/tcp-int.cc,v 1.15 2000/09/01 03:04:07 haoboy Exp $
 */


/*
 * We separate TCP functionality into two parts: that having to do with 
 * providing a reliable, ordered byte-stream service, and that having to do with
 * congestion control and loss recovery. The former is done on a per-connection
 * basis and is implemented as part of IntTcpAgent ("integrated TCP"). The 
 * latter is done in an integrated fashion across multiple TCP connections, and
 * is implemented as part of TcpSessionAgent ("TCP session"). TcpSessionAgent is
 * derived from CorresHost ("correspondent host"), which keeps track of the 
 * state of all TCP (TCP/Int) connections to a host that it is corresponding 
 * with.
 *
 * The motivation for this separation of functionality is to make an ensemble of
 * connection more well-behaved than a set of independent TCP connections.
 * The packet loss rate is cut down and the chances of losses being recovered 
 * via data-driven techniques (rather than via timeouts) is improved. At the 
 * same time, we do not introduce any unnecessary coupling between the 
 * logically-independent byte-streams that the set of connections represents. 
 * This is in contrast to the coupling that is inherent in the multiplexing at 
 * the application layer of multiple byte-streams onto a single TCP connection.
 */

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

#include "packet.h"
#include "ip.h"
#include "tcp.h"
#include "flags.h"
#include "nilist.h"
#include "tcp-int.h"
#include "chost.h"
#include "tcp-session.h"
#include "random.h"

Islist<TcpSessionAgent> TcpSessionAgent::sessionList_;

static class IntTcpClass : public TclClass {
public:
        IntTcpClass() : TclClass("Agent/TCP/Int") {}
        TclObject* create(int, const char*const*) {
                return (new IntTcpAgent());
        }
} class_tcp_int;

IntTcpAgent::IntTcpAgent() : TcpAgent(), slink(), 
        session_(0), closecwTS_(0), lastTS_(-1), count_(0), 
        wt_(1), wndIncSeqno_(0), num_thresh_dupack_segs_(0)
{
        bind("rightEdge_", &rightEdge_);
        bind("uniqTS_", &uniqTS_);
        bind("winInc_", &winInc_);
        bind("winMult_", &winMult_);
}

int
IntTcpAgent::command(int argc, const char*const* argv)
{
        Tcl& tcl = Tcl::instance();

        if (argc == 3) {
                if (!strcmp(argv[1], "setwt")) {
                        if (!session_)
                                createTcpSession();
                        session_->set_weight(this,atoi(argv[2]));
                        return (TCL_OK);
                }
        }
        else if (argc == 2) {
                if (!strcmp(argv[1], "session")) {
                        if (!session_)
                                createTcpSession();
                        tcl.resultf("%s", session_->name());
                        return (TCL_OK);
                }
        }
        return (TcpAgent::command(argc,argv));
}

/* 
 * Update the ack information and reset the timer. RTT update is done in 
 * TcpSessionAgent.
 */
void
IntTcpAgent::newack(Packet* pkt)
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        last_ack_ = tcph->seqno();
        highest_ack_ = last_ack_;

        if (t_seqno_ < last_ack_ + 1)
                t_seqno_ = last_ack_ + 1;
        /* if the connection is done, call finish() */
        if ((highest_ack_ >= curseq_-1) && !closed_) {
                closed_ = 1;
                finish();
        }
}

void 
IntTcpAgent::recv(Packet *pkt, Handler *)
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        int amt_data_acked = 0;

        if (tcph->seqno() > last_ack_) {
                amt_data_acked = tcph->seqno() - last_ack_;
                newack(pkt);
        } 
        session_->recv(this, pkt, amt_data_acked);
}

void
IntTcpAgent::createTcpSession()
{
        Tcl& tcl = Tcl::instance();

        tcl.evalf("%s set node_", name());
        tcl.evalf("%s createTcpSession %d", tcl.result(), daddr());
        Islist_iter<TcpSessionAgent> session_iter(TcpSessionAgent::sessionList_);
        TcpSessionAgent *cur;

        while ((cur = session_iter()) != NULL) {
                if (cur->addr()/256 == addr() && cur->daddr() == daddr()) {
                        session_ = cur;
                        break;
                }
        }
        if (!session_) {
                printf("In IntTcpAgent::createTcpSession(): failed\n");
                abort();
        }
        session_->add_agent(this, size_, winMult_, winInc_, ssthresh_);
}

void
IntTcpAgent::output(int seqno, int reason)
{
        Packet *pkt = allocpkt();
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        tcph->seqno() = seqno;
        tcph->ts() = Scheduler::instance().clock();
        tcph->ts_echo() = ts_peer_;
        tcph->reason() = reason;

        session_->setflags(pkt);
        
        int bytes = hdr_cmn::access(pkt)->size();

        /* call helper function to fill in additional fields */
        output_helper(pkt);

        ++ndatapack_;
        ndatabytes_ += bytes;
        send(pkt, 0);
        if (seqno == curseq_ && seqno > maxseq_)
                idle();  // Tell application I have sent everything so far
        if (seqno > maxseq_) {
                maxseq_ = seqno;
        }
        else {
                ++nrexmitpack_;
                nrexmitbytes_ += bytes;
        }
        if (wndIncSeqno_ == 0)
                wndIncSeqno_ = maxseq_;
}


/*
 * Unlike in other flavors of TCP, IntTcpAgent does not decide when to send 
 * packets and how many of them to send. That decision is made by 
 * TcpSessionAgent. So send_much() does little more than defer to 
 * TcpSessionAgent.
 */
void
IntTcpAgent::send_much(int force, int reason, int /*maxburst*/)
{
        if (!session_)
                createTcpSession();
        if (!force && delsnd_timer_.status() == TIMER_PENDING)
                return;
        if (overhead_ && !force) {
                delsnd_timer_.resched(Random::uniform(overhead_));
                return;
        }
        session_->send_much(this, force,reason);
}

/*
 * Send one new packet.
 */
void
IntTcpAgent::send_one(int sessionSeqno)
{
        int dst_addr = daddr();
        int dst_port = dport();
        int sport = port();

        if (!session_)
                createTcpSession();
        /* 
         * XXX We assume that the session layer has already made sure that
         * we have data to send.
         */
        output(t_seqno_++); 
        session_->add_pkts(size_, t_seqno_ - 1, sessionSeqno,
                           dst_addr, dst_port, sport, lastTS_, this); 
}


/*
 * open up the congestion window
 */
void 
IntTcpAgent::opencwnd()
{
        session_->opencwnd(size_, this);
}

/*
 * close down the congestion window
 */
void 
IntTcpAgent::closecwnd(int how)
{   
        session_->closecwnd(how, this);
}

Segment *
IntTcpAgent::rxmit_last(int reason, int seqno, int sessionSeqno, double /*ts*/)
{
        session_->agent_rcov(this);
        /* 
         * XXX kludge -- IntTcpAgent is not supposed to deal with 
         * rtx timer 
         */
        session_->reset_rtx_timer(1,0); 
        output(seqno, reason);
        daddr_ = daddr();
        dport_ = dport();
        sport_ = port();
        return (session_->add_pkts(size_, seqno, sessionSeqno, daddr_, 
                                   dport_, sport_, lastTS_, this));
        return NULL;
}
unsigned long output_helper_count=0;
double last_clock=0;
void
IntTcpAgent::output_helper(Packet *p)
{
        double now = Scheduler::instance().clock();
        output_helper_count++;
        last_clock = now;
        hdr_tcp *tcph = hdr_tcp::access(p);

        /* This is to make sure that we get unique times for each xmission */
        while (uniqTS_ && now <= lastTS_) {
                now += 0.000001; // something arbitrarily small
        }

        lastTS_ = now;
        tcph->ts() = now;
        /* if this is a fast start pkt and not a retransmission, mark it */
        if (session_->fs_pkt() && tcph->seqno() > maxseq_)
                hdr_flags::access(p)->fs_ = 1;
        return;
}

int 
IntTcpAgent::data_left_to_send() {
        return (curseq_ > t_seqno_);
}

---