rlm.cc

Go to the documentation of this file.

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * Copyright (c) 1994-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 Computer Systems
 *  Engineering Group at Lawrence Berkeley Laboratory.
 * 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.
 */

#ifndef lint
static char rcsid[] =
    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/mcast/rlm.cc,v 1.8 2001/12/20 19:27:44 haldar Exp $ (LBL)";
#endif

#include "agent.h"
#include "node.h"

struct srcpkt {
    double off;
    int level;
    int size;
    srcpkt* next;
};


class RLM_Sender : public Agent {
 public:
    RLM_Sender();
    ~RLM_Sender();
    int command(int argc, const char*const* argv);
 protected:
    virtual void timeout(int);
    void start();
    void stop();
    void sched_next();
    void sendpkt(int size, int level);
    void addpkt(double off, int size, int level);
    int running_;
    double interval_;
    srcpkt* pkt_;
    srcpkt* allpkt_;
    /*XXX make size dynamic*/
#define MAXLEVEL 32
    int seqno_[MAXLEVEL];
    int blkno_;
};

static class RLMMatcher : public Matcher {
public:
    RLMMatcher() : Matcher("agent") {}
    TclObject* match(const char* id) {
        if (strcmp(id, "rlm-sender") == 0)
            return (new RLM_Sender());
        return (0);
    }
} matcher_rlm;

RLM_Sender::RLM_Sender() : Agent(PT_CBR), pkt_(0), allpkt_(0)
{
    Tcl& tcl = Tcl::instance();
    link_time("ns_rlm", "interval", &interval_, 0);
    link_int("ns_rlm", "packet-size", &size_, 0);
    running_ = 0;
    memset(seqno_, 0, sizeof(seqno_));
    blkno_ = 0;
}

RLM_Sender::~RLM_Sender()
{
    /*XXX free allpkt_ */
}

void RLM_Sender::start()
{
    if (allpkt_ != 0) {
        running_ = 1;
        pkt_ = allpkt_;
        sched(pkt_->off, 0);
    }
}

void RLM_Sender::stop()
{
    running_ = 0;
}

void RLM_Sender::sched_next()
{
    srcpkt* p = pkt_;
    srcpkt* n = p->next;
    double t;
    if (n == 0) {
        t = interval_;
        n = allpkt_;
        ++blkno_;
        blkitem_ = 0;
    } else
        t = 0.;
    t += n->off - p->off;
    pkt_ = n;
    sched(t, 0);
}

void RLM_Sender::timeout(int)
{
    if (running_) {
        sendpkt(pkt_->size, pkt_->level);
        sched_next();
    }
}

void RLM_Sender::sendpkt(int size, int level)
{
    Packet* p = allocpkt(seqno_[level]++);
    IPHeader *iph = IPHeader::access(p->bits());
    RLMHeader *rh = RLMHeader::access(p->bits());
    rh->blkno() = blkno_;
    rh->blkitem() = blkitem_++;
    iph->size() = size;
    iph->daddr() += level;
#ifdef notdef
    iph->class() += level;/*XXX*/
#endif
    node_->transmit(p);
}

extern double time_atof(const char*);

void RLM_Sender::addpkt(double off, int size, int level)
{
    srcpkt* sp = new srcpkt;
    sp->next = 0;
    sp->off = off;
    sp->size = size;
    sp->level = level;
    srcpkt** p;
    for (p = &allpkt_; *p != 0; p = &(*p)->next)
        if (sp->off < (*p)->off)
            break;
    *p = sp;
}

/*
 * $obj start
 * $obj stop
 * $obj packet $off $size $level
 */
int RLM_Sender::command(int argc, const char*const* argv)
{
    if (argc == 2) {
        if (strcmp(argv[1], "start") == 0) {
            start();
            return (TCL_OK);
        }
        if (strcmp(argv[1], "stop") == 0) {
            stop();
            return (TCL_OK);
        }
    }
    if (argc == 5) {
        if (strcmp(argv[1], "packet") == 0) {
            double off = time_atof(argv[2]);
            int size = atoi(argv[3]);
            int level = atoi(argv[4]);
            addpkt(off, size, level);
            return (TCL_OK);
        }
    }
    return (Agent::command(argc, argv));
}

class RLM_Receiver : public Agent {
 public:
    RLM_Receiver();
    int command(int argc, const char*const* argv);
    void recv(Packet* pkt);
protected:
    char* proc_;
    int loss_;
    int expected_;
    int bytes_;

    int pblk_;
    int pseq_[MAXLEVEL];
};

static class RLM_ReceiverMatcher : public Matcher {
public:
    RLM_ReceiverMatcher() : Matcher("agent") {}
    TclObject* match(const char* id) {
        if (strcmp(id, "rlm-receiver") == 0)
            return (new RLM_Receiver());
        return (0);
    }
} matcher_cbr;

RLM_Receiver::RLM_Receiver() : Agent(-1), proc_(0), expected_(-1)
{
    bytes_ = 0;
    loss_ = 0;
    link_int(0, "loss", &loss_, 1);
    link_int(0, "bytes", &bytes_, 1);
}

void RLM_Receiver::recv(Packet* pkt)
{
    IPHeader *iph = IPHeader::access(pkt->bits());
    SequenceHeader *sh = SequenceHeader::access(pkt->bits());
    bytes_ += iph->size();
    int seqno = sh->seqno();
    int blkno = seqno >> 16;
    seqno &= 0xffff;
    
    /*
     * Check for lost packets
     */
    if (expected_ >= 0) {
        int loss = sh->seqno() - expected_;
        if (loss > 0) {
            loss_ += loss;
            if (proc_ != 0)
                Tcl::instance().eval(proc_);
        }
    }
    expected_ = sh->seqno() + 1;
    Packet::free(pkt);
}

/*
 * $proc interval $interval
 * $proc size $size
 */
int RLM_Receiver::command(int argc, const char*const* argv)
{
    if (argc == 2) {
        if (strcmp(argv[1], "clear") == 0) {
            expected_ = -1;
            return (TCL_OK);
        }
    } else if (argc == 3) {
        if (strcmp(argv[1], "proc") == 0) {
            const char* proc = argv[2];
            int n = strlen(proc) + 1;
            delete proc_;
            proc_ = new char[n];
            strcpy(proc_, proc);
            return (TCL_OK);
        }
    }
    return (Agent::command(argc, argv));
}

---