/Users/yzchen/ns/ns-allinone-2.33/ns-2.33/mcast/srm-topo.h

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * Copyright (c) Xerox Corporation 1997. All rights reserved.
 *  
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linking this file statically or dynamically with other modules is making
 * a combined work based on this file.  Thus, the terms and conditions of
 * the GNU General Public License cover the whole combination.
 *
 * In addition, as a special exception, the copyright holders of this file
 * give you permission to combine this file with free software programs or
 * libraries that are released under the GNU LGPL and with code included in
 * the standard release of ns-2 under the Apache 2.0 license or under
 * otherwise-compatible licenses with advertising requirements (or modified
 * versions of such code, with unchanged license).  You may copy and
 * distribute such a system following the terms of the GNU GPL for this
 * file and the licenses of the other code concerned, provided that you
 * include the source code of that other code when and as the GNU GPL
 * requires distribution of source code.
 *
 * Note that people who make modified versions of this file are not
 * obligated to grant this special exception for their modified versions;
 * it is their choice whether to do so.  The GNU General Public License
 * gives permission to release a modified version without this exception;
 * this exception also makes it possible to release a modified version
 * which carries forward this exception.
 *
 * This file contributed by Suchitra Raman <sraman@parc.xerox.com>, June 1997.
 */

#ifndef srm_topo_h
#define srm_topo_h
#include "scheduler.h"
#include "random.h"

#define tprintf(x) { \
        Scheduler &_s = Scheduler::instance(); \
        double _now = _s.clock(); \
        printf("%f : ", _now); \
        printf x;\
        fflush(stdout);\
}              
#define SRM_DATA 0
#define SRM_RREQ 1
#define SRM_PENDING_RREQ 2


#define SRM_SUPPRESS 0
#define SRM_NO_SUPPRESS 1
#define SRM_NOIF -1


/* 
 * Events -- passed on from node to node 
 */
class SRM_Event : public Event {
 public:
        SRM_Event(int s=0, int t=0, int i=0) : seqno_(s), iif_(i), type_(t) {}
        SRM_Event(SRM_Event *e);
        int seqno() { return seqno_; }
        int iif() { return iif_; }

        int type() { return type_; }    
        void type(int t) { type_ = t; }
        void iif(int i) { iif_ = i; }

 protected:
        int seqno_;
        int iif_;
        int type_;
};


/* 
 * SRM_Request - Stored version of request to cancel when a similar
 * request is heard. Right now, a request only has an ID.
 * A real implementation would have a sequence range, if ADUs
 * were stacked.
 */

class SRM_Request {
 public:
        SRM_Request(SRM_Event *e) : event_(e), next_(0) {};
        ~SRM_Request();
        void cancel_timer();

        SRM_Event *event_;
        SRM_Request *next_;
};


/* 
 * Light-weight node abstraction only to store SRM 
 * protocol state information.
 */
class SrmNode : public Handler {
 public:
        SrmNode() : id_(0), expected_(0), pending_(0) {}
        void id(int i) { id_ = i; }
        void handle(Event *);
        void send(SRM_Event *);

        void append(SRM_Event *);
        void remove(int , int);


 protected:
        void sched_nack(int);
        void dump_packet(SRM_Event *e);

        int id_;
        int expected_;
        SRM_Request *pending_;
};


/*
 * Interface -- Contains the node id of a node and 
 * a pointer to the next Interface 
 */
class Interface {
 public: 
        Interface(int in) : in_(in), next_(0) { }

        int in_;
        Interface *next_;
};

class Interface_List {
 public: 
        Interface_List() : head_(0) { }
        ~Interface_List();
        void append(int in);

        Interface* head_;
};


/* 
 * Topology -- Line, Tree, Star derived from this base class.
 */
class Topology *topology; 

class Topology : public TclObject {
 public:
        Topology(int nn, int src);
        ~Topology();
        virtual void flood(int, int) = 0;
        virtual Interface_List *oif(int node, int iif) = 0;

        int command(int argc, const char*const* argv);
        inline int idx() { return idx_; }
        SrmNode *node(int nn);
        virtual double backoff(int dst) = 0;
        inline double delay() { return delay_;}
        inline double D() { return D_;}
        virtual double delay(int src, int dst) = 0;
        int rtt_estimated() { return rtt_est_; }

 protected:
        SrmNode *node_; 
        int idx_;
        int src_;

        double delay_;
        double D_;
        double frac_;
        double det_;
        double rand_;
        int rtt_est_;
};

/* 
 * Line -- Chain with 'nn' nodes 
 */
class Line : public Topology {
 public: 
        Line(int n, int src) : Topology(n, src) { 
                topology = this; 
                bind("c_", &c_);
                bind("alpha_", &alpha_);
                bind("beta_", &beta_);          
                bind("c2func_", &c2func_);              
        }
        void flood(int, int);
        Interface_List *oif(int node, int iif);
        double backoff(int dst);
        double delay(int src, int dst); 
 protected:
        int src_;
        int c_;
        double alpha_;
        double beta_;
        int c2func_;
};

#define LOG  0
#define SQRT 1
#define LINEAR 2
#define CONSTANT 3

/* 
 * BTree -- Binary Tree with 'nn' nodes 
 */
class BTree : public Topology {
 public: 
        BTree(int n, int src) : Topology(n, src) { 
                topology = this; 
                bind("c_", &c_);
                bind("alpha_", &alpha_);
                bind("beta_", &beta_);
                bind("c2func_", &c2func_);
        }
        void flood(int, int);
        Interface_List *oif(int node, int iif);
        double backoff(int dst);
        double delay(int src, int dst); 

 protected:
        int src_;
        int c_;
        double alpha_;
        double beta_;
        int c2func_;
};


/* 
 * Star -- Complete graph with (nn-1) receivers and 1 sender 
 * at a distance 'Delay_' from each receiver. 
 */
class Star : public Topology {
 public:
        Star(int n, int src) : Topology(n, src) { 
                topology = this; 

                bind("c_", &c_);
                bind("alpha_", &alpha_);
                bind("beta_", &beta_);
        }

        void flood(int, int);
        Interface_List *oif(int node, int iif);
        double backoff(int dst);
        inline int c() { return c_; }
        double delay(int src, int dst); 

 protected:
        int src_;
        int c_;
        double alpha_;
        double beta_;
};
#endif