chost.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.
 *
 * $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp/chost.cc,v 1.13 2000/09/01 03:04:05 haoboy Exp $
 */

/*
 * Functions invoked by TcpSessionAgent
 */
#include "nilist.h"
#include "chost.h"
#include "tcp-int.h"
#include "random.h"

CorresHost::CorresHost() : slink(), TcpFsAgent(),
        lastackTS_(0), dontAdjustOwnd_(0), dontIncrCwnd_(0), rexmtSegCount_(0),
        connWithPktBeforeFS_(NULL)
{
        nActive_ = nTimeout_ = nFastRec_ = 0;
        ownd_ = 0;
        owndCorrection_ = 0;
        closecwTS_ = 0;
        connIter_ = new Islist_iter<IntTcpAgent> (conns_);
        rtt_seg_ = NULL;
}


/*
 * Open up the congestion window.
 */
void 
CorresHost::opencwnd(int /*size*/, IntTcpAgent *sender)
{
        if (cwnd_ < ssthresh_) {
                /* slow-start (exponential) */
                cwnd_ += 1;
        } else {
                /* linear */
                //double f;
                if (!proxyopt_) {
                        switch (wnd_option_) {
                        case 0:
                                if ((count_ = count_ + winInc_) >= cwnd_) {
                                        count_ = 0;
                                        cwnd_ += winInc_;
                                }
                                break;
                        case 1:
                                /* This is the standard algorithm. */
                                cwnd_ += winInc_ / cwnd_;
                                break;
                        default:
#ifdef notdef
                                /*XXX*/
                                error("illegal window option %d", wnd_option_);
#endif
                                abort();
                        }
                } else {        // proxy
                        switch (wnd_option_) {
                        case 0: 
                        case 1:
                                if (sender->highest_ack_ >= sender->wndIncSeqno_) {
                                        cwnd_ += winInc_;
                                        sender->wndIncSeqno_ = 0;
                                }
                                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 
CorresHost::closecwnd(int how, double ts, IntTcpAgent *sender)
{
        if (proxyopt_) {
                if (!sender || ts > sender->closecwTS_)
                        closecwnd(how, sender);
        }
        else {
                if (ts > closecwTS_)
                        closecwnd(how, sender);
        }
}

void 
CorresHost::closecwnd(int how, IntTcpAgent *sender)
{
        int sender_ownd = 0;
        if (sender)
                sender_ownd = sender->maxseq_ - sender->highest_ack_;
        closecwTS_ = Scheduler::instance().clock();
        if (proxyopt_) {
                if (sender)
                        sender->closecwTS_ = closecwTS_;
                how += 10;
        }
        switch (how) {
        case 0:
        case 10:
                /* timeouts */

                /* 
                 * XXX we use cwnd_ instead of ownd_ here, which may not be
                 * appropriate if the sender does not fully utilize the
                 * available congestion window (ownd_ < cwnd_).
                 */
                ssthresh_ = int(cwnd_ * winMult_);
                cwnd_ = int(wndInit_);
                break;
                
        case 1:
                /* Reno dup acks, or after a recent congestion indication. */

                /* 
                 * XXX we use cwnd_ instead of ownd_ here, which may not be
                 * appropriate if the sender does not fully utilize the
                 * available congestion window (ownd_ < cwnd_).
                 */
                cwnd_ *= winMult_;
                ssthresh_ = int(cwnd_);
                if (ssthresh_ < 2)
                        ssthresh_ = 2;
                break;

        case 11:
                /* Reno dup acks, or after a recent congestion indication. */
                /* XXX fix this -- don't make it dependent on ownd */
                cwnd_ = ownd_ - sender_ownd*(1-winMult_);
                ssthresh_ = int(cwnd_);
                if (ssthresh_ < 2)
                        ssthresh_ = 2;
                break;

        case 3:
        case 13:
                /* idle time >= t_rtxcur_ */
                cwnd_ = wndInit_;
                break;
                
        default:
                abort();
        }
        fcnt_ = 0.;
        count_ = 0;
        if (sender)
                sender->count_ = 0;
}

Segment* 
CorresHost::add_pkts(int /*size*/, int seqno, int sessionSeqno, int daddr, int dport, 
                     int sport, double ts, IntTcpAgent *sender)
{
        class Segment *news;

        ownd_ += 1;
        news = new Segment;
        news->seqno_ = seqno;
        news->sessionSeqno_ = sessionSeqno;
        news->daddr_ = daddr;
        news->dport_ = dport;
        news->sport_ = sport;
        news->ts_ = ts;
        news->size_ = 1;
        news->dupacks_ = 0;
        news->later_acks_ = 0;
        news->thresh_dupacks_ = 0;
        news->partialack_ = 0;
        news->rxmitted_ = 0;
        news->sender_ = sender;
        seglist_.append(news);
        return news;
}

void
CorresHost::adjust_ownd(int size) 
{
        if (double(owndCorrection_) < size)
                ownd_ -= min(double(ownd_), size - double(owndCorrection_));
        owndCorrection_ -= min(double(owndCorrection_),size);
        if (double(ownd_) < -0.5 || double(owndCorrection_ < -0.5))
                printf("In adjust_ownd(): ownd_ = %g  owndCorrection_ = %g\n", double(ownd_), double(owndCorrection_));
}

int
CorresHost::clean_segs(int /*size*/, Packet *pkt, IntTcpAgent *sender, int sessionSeqno, int amt_data_acked)
{ 
    Segment *cur, *prev=NULL, *newseg;
    int i;
    //int rval = -1;

    /* remove all acked pkts from list */
    int latest_susp_loss = rmv_old_segs(pkt, sender, amt_data_acked);
    /* 
     * XXX If no new data is acked and the last time we shrunk the window 
     * covers the most recent suspected loss, update the estimate of the amount
     * of outstanding data.
     */
    if (amt_data_acked == 0 && latest_susp_loss <= recover_ && 
        !dontAdjustOwnd_ && last_cwnd_action_ != CWND_ACTION_TIMEOUT) {
            owndCorrection_ += min(double(ownd_),1);
            ownd_ -= min(double(ownd_),1);
    }
    /*
     * A pkt is a candidate for retransmission if it is the leftmost one in the
     * unacked window for the connection AND has at least numdupacks_
     * dupacks/later acks AND (at least one dupack OR a later packet also
     * with the threshold number of dup/later acks). A pkt is also a candidate
     * for immediate retransmission if it has partialack_ set, indicating that
     * a partial new ack has been received for it.
     */

    for (i=0; i < rexmtSegCount_; i++) {
            int remove_flag = 0;
            /* 
             * curArray_ only contains segments that are the first oldest
             * unacked segments of their connection (i.e., they are at the left
             * edge of their window) and have either received a
             * partial ack and/or have received at least cur->numdupacks_
             * dupacks/later acks. Thus, segments in curArray_ have a high
             * probability (but not certain) of being eligible for 
             * retransmission. Using curArray_ avoids having to scan
             * through all the segments.
             */
            cur = curArray_[i];
            prev = prevArray_[i];
            if (cur->partialack_ || cur->dupacks_ > 0 || 
                cur->sender_->num_thresh_dupack_segs_ > 1 ) {
                    if (cur->thresh_dupacks_) {
                            cur->thresh_dupacks_ = 0;
                            cur->sender_->num_thresh_dupack_segs_--;
                    }
                    if (cur->sessionSeqno_ <= recover_ && 
                        last_cwnd_action_ != CWND_ACTION_TIMEOUT /* XXX 2 */)
                            dontAdjustOwnd_ = 1;
                    if ((cur->sessionSeqno_ > recover_) || 
                        (last_cwnd_action_ == CWND_ACTION_TIMEOUT /* XXX 2 */)
                        || (proxyopt_ && cur->seqno_ > cur->sender_->recover_)
                        || (proxyopt_ && cur->sender_->last_cwnd_action_ == CWND_ACTION_TIMEOUT /* XXX 2 */)) { 
                            /* new loss window */
                            closecwnd(1, cur->ts_, cur->sender_);
                            recover_ = sessionSeqno - 1;
                            last_cwnd_action_ = CWND_ACTION_DUPACK /* XXX 1 */;
                            cur->sender_->recover_ = cur->sender_->maxseq_;
                            cur->sender_->last_cwnd_action_ = 
                                    CWND_ACTION_DUPACK /* XXX 1 */;
                            dontAdjustOwnd_ = 0;
                    }
                    if ((newseg = cur->sender_->rxmit_last(TCP_REASON_DUPACK, 
                           cur->seqno_, cur->sessionSeqno_, cur->ts_))) {
                            newseg->rxmitted_ = 1;
                            adjust_ownd(cur->size_);
                            if (!dontAdjustOwnd_) {
                                    owndCorrection_ += 
                                            min(double(ownd_),cur->dupacks_);
                                    ownd_ -= min(double(ownd_),cur->dupacks_);
                            }
                            seglist_.remove(cur, prev);
                            remove_flag = 1;
                            delete cur;
                    }
                    /* 
                     * if segment just removed used to be the one just previous
                     * to the next segment in the array, update prev for the
                     * next segment
                     */
                    if (remove_flag && cur == prevArray_[i+1])
                            prevArray_[i+1] = prev;
            }
    }
    rexmtSegCount_ = 0;
    return(0);
}
                    

int
CorresHost::rmv_old_segs(Packet *pkt, IntTcpAgent *sender, int amt_data_acked)
{
        Islist_iter<Segment> seg_iter(seglist_);
        Segment *cur, *prev=0;
        int found = 0;
        int done = 0;
        int new_data_acked = 0;
        int partialack = 0;
        int latest_susp_loss = -1;
        hdr_tcp *tcph = hdr_tcp::access(pkt);

        if (tcph->ts_echo() > lastackTS_)
                lastackTS_ = tcph->ts_echo();

        while (((cur = seg_iter()) != NULL) &&
               (!done || tcph->ts_echo() > cur->ts_)) {
                int remove_flag = 0;
                /* ack for older pkt of another connection */
                if (sender != cur->sender_ && tcph->ts_echo() > cur->ts_) { 
                        if (!disableIntLossRecov_)
                                cur->later_acks_++;
                        latest_susp_loss = 
                                max(latest_susp_loss,cur->sessionSeqno_);
                        dontIncrCwnd_ = 1;
                } 
                /* ack for same connection */
                else if (sender == cur->sender_) {
                        /* found packet acked */
                        if (tcph->seqno() == cur->seqno_ && 
                            tcph->ts_echo() == cur->ts_) 
                                found = 1;
                        /* higher ack => clean up acked packets */
                        if (tcph->seqno() >= cur->seqno_) {
                                adjust_ownd(cur->size_);
                                seglist_.remove(cur, prev);
                                remove_flag = 1;
                                new_data_acked += cur->size_;
                                if (new_data_acked >= amt_data_acked)
                                        done = 1;
                                if (prev == cur) 
                                        prev = NULL;
                                if (cur == rtt_seg_)
                                        rtt_seg_ = NULL;
                                delete cur;
                                if (seg_iter.get_cur() && prev)
                                        seg_iter.set_cur(prev);
                                else if (seg_iter.get_cur())
                                        seg_iter.set_cur(seg_iter.get_last());
                        } 
                        /* partial new ack => rexmt immediately */
                        /* XXX should we check recover for session? */
                        else if (amt_data_acked > 0 && 
                                 tcph->seqno() == cur->seqno_-1 &&
                                 cur->seqno_ <= sender->recover_ &&
                                 sender->last_cwnd_action_ == CWND_ACTION_DUPACK) {
                                cur->partialack_ = 1;
                                partialack = 1;
                                latest_susp_loss = 
                                        max(latest_susp_loss,cur->sessionSeqno_);
                                if (new_data_acked >= amt_data_acked)
                                        done = 1;
                                dontIncrCwnd_ = 1;
                        }
                        /* 
                         * If no new data has been acked AND this segment has
                         * not been retransmitted before AND the ack indicates 
                         * that this is the next segment to be acked, then
                         * increment dupack count.
                         */
                        else if (!amt_data_acked && !cur->rxmitted_ &&
                                 tcph->seqno() == cur->seqno_-1) {
                                cur->dupacks_++;
                                latest_susp_loss = 
                                        max(latest_susp_loss,cur->sessionSeqno_);
                                done = 1;
                                dontIncrCwnd_ = 1;
                        } 
                }
                if (cur->dupacks_+cur->later_acks_ >= sender->numdupacks_ &&
                    !cur->thresh_dupacks_) {
                        cur->thresh_dupacks_ = 1;
                        cur->sender_->num_thresh_dupack_segs_++;
                }

                if (amt_data_acked==0 && tcph->seqno()==cur->seqno_-1)
                        done = 1;
                /* XXX we could check for rexmt candidates here if we ignore 
                   the num_thresh_dupack_segs_ check */
                if (!remove_flag &&
                    cur->seqno_ == cur->sender_->highest_ack_ + 1 &&
                    (cur->dupacks_ + cur->later_acks_ >= sender->numdupacks_ ||
                     cur->partialack_)) {
                        curArray_[rexmtSegCount_] = cur;
                        prevArray_[rexmtSegCount_] = prev;
                        rexmtSegCount_++;
                }
                if (!remove_flag)
                        prev = cur;
        }
        /* partial ack => terminate fast start mode */
        if (partialack && fs_enable_ && fs_mode_) {
                timeout(TCP_TIMER_RESET);
                rexmtSegCount_ = 0;
        }
        return latest_susp_loss;
}
        
void
CorresHost::add_agent(IntTcpAgent *agent, int /*size*/, double winMult, 
                      int winInc, int /*ssthresh*/)
{
        if (nActive_ >= MAX_PARALLEL_CONN) {
                printf("In add_agent(): reached limit of number of parallel conn (%d); returning\n", nActive_);
                return;
        }
        nActive_++;
        if ((!fixedIw_ && nActive_ > 1) || cwnd_ == 0)
                cwnd_ += 1; /* XXX should this be done? */
        wndInit_ = 1;
        winMult_ = winMult;
        winInc_ = winInc;
/*      ssthresh_ = ssthresh;*/
        conns_.append(agent);
}

int
CorresHost::ok_to_snd(int /*size*/)
{
        if (ownd_ <= -0.5)
                printf("In ok_to_snd(): ownd_ = %g  owndCorrection_ = %g\n", double(ownd_), double(owndCorrection_));
        return (cwnd_ >= ownd_+1);
}

---