mc-agent.h

模拟器提供了一个简单易用的平台

/**************************************************
 *
  File: mc-agent.h
  Author: Suman Banerjee <[e-mail]>
  Date: 15th March, 2001
  Terms: GPL

  Narada implementation in myns

  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.
 *
**************************************************/

#ifndef _MC_AGENT_H_
#define _MC_AGENT_H_

#include <linked-list.h>
#include <agent.h>
#include <timer.h>
#include <constants.h>
#include "app-packet.h"

#define LOG_MCAGENT_START
#define LOG_MCAGENT_STOP
#define LOG_APP_RP
#undef LOG_APP_REFRESH
#undef LOG_APP_REFRESH_OLD
#undef LOG_MESH_REFRESH
#undef LOG_APP_MESH_RT
#undef LOG_APP_NEIGHBOR
#undef LOG_SELECT_NEIGHBOR
#define LOG_LINK_ADD
#define LOG_LINK_DROP
#undef LOG_TIMEOUTS
#undef LOG_PURGE_NEIGHBOR
#define LOG_DATA
#define LOG_DATA_LOSS

//#define MAXMMARRAYSIZE 600

extern NamedConstant const_seek_nbr_cnt;
#define CONST_SEEK_NBR_CNT (const_seek_nbr_cnt.getval().u.i)

extern NamedConstant const_mesh_neighbors;
#define CONST_MESH_NEIGHBORS (const_mesh_neighbors.getval().u.i)

extern NamedConstant const_mesh_neighbor_keepalive_period; 
#define CONST_MESH_NEIGHBOR_KEEPALIVE_PERIOD (const_mesh_neighbor_keepalive_period.getval().u.d) /* in seconds */

extern NamedConstant const_mesh_neighbor_refresh_timeout; 
#define CONST_MESH_NEIGHBOR_REFRESH_TIMEOUT (const_mesh_neighbor_refresh_timeout.getval().u.d) /* in seconds */

//sri's code 
extern NamedConstant const_mesh_rt_exchange_period; 
#define CONST_MESH_RT_EXCHANGE_PERIOD (const_mesh_rt_exchange_period.getval().u.d) // in seconds

extern NamedConstant const_mesh_rt_exchange_timeout; 
#define CONST_MESH_RT_EXCHANGE_TIMEOUT (const_mesh_rt_exchange_timeout.getval().u.d) // in seconds 

extern NamedConstant const_mesh_link_add_period; 
#define CONST_MESH_LINK_ADD_PERIOD (const_mesh_link_add_period.getval().u.d) // in seconds

extern NamedConstant const_mesh_link_drop_period;
#define CONST_MESH_LINK_DROP_PERIOD (const_mesh_link_drop_period.getval().u.d) // in seconds 

extern NamedConstant const_mesh_setup_neighbor_timeout; 
#define CONST_MESH_SETUP_NEIGHBOR_TIMEOUT (const_mesh_setup_neighbor_timeout.getval().u.d) // in seconds 

extern NamedConstant const_data_transmit_interval;
#define CONST_DATA_TRANSMIT_INTERVAL (const_data_transmit_interval.getval().u.d)

extern NamedConstant linkdropthreshold;
#define LINKDROPTHRESHOLD (linkdropthreshold.getval().u.i)

extern NamedConstant linkaddthreshold; 
#define LINKADDTHRESHOLD (linkaddthreshold.getval().u.d)

extern NamedConstant infinitelinkcost; 
#define INFINITELINKCOST  (infinitelinkcost.getval().u.d)

extern NamedConstant invalid;
#define INVAlID (invalid.getval().u.i)


extern NamedConstant maxmeshmembers; 
#define MAXMESHMEMBERS (maxmeshmembers.getval().u.i)

extern NamedConstant random_data_source; 
#define RANDOM_DATA_SOURCE (random_data_source.getval().u.i)
//

struct MeshMember {

  AgentInfo ainfo;
  double last_refresh;
  int last_seq_no;
  bool is_stopped;
  bool neighbor_setup_pending;
  bool is_neighbor;
  //sri's code
  double linkcost; 
  int consensuscost; 
  bool gotrt; 
  bool * source; 
  long last_data_seq_no; 
 //
  MeshMember (int aid, int nid, double lr) {
    ainfo.agent_id = aid;
    ainfo.node_id = nid;
    last_refresh = lr;
    last_seq_no = -1;
    is_stopped = false;
    neighbor_setup_pending = false;
    is_neighbor = false;
    last_data_seq_no = -1; 
    source = new (bool[MAXMESHMEMBERS]);
    for (int i = 0; i < MAXMESHMEMBERS; i++) 
      source[i] = false; 
  }
};

//sri's code 
struct MeshRoutingTable {

  bool * valid;
  int * pathlen;  
  AgentInfo ** path; 
  double * cost; 
};
//

class mcAgent;

class MeshRefreshTimeoutTimer : public Timer {

public :
  mcAgent *mca;

  MeshRefreshTimeoutTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);

};

class MeshKeepAliveTimer : public Timer {

public :
  mcAgent *mca;

  MeshKeepAliveTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);

};

//sri's code
class MeshLinkAddTimer : public Timer {

public :
  mcAgent *mca;

  MeshLinkAddTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);

};

class MeshLinkDropTimer : public Timer {

public:
  mcAgent *mca; 

  MeshLinkDropTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);
};

class MeshRTExchangeTimer : public Timer {

public :
  mcAgent *mca;

  MeshRTExchangeTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);

};

class MeshRTExchangeCheckTimer : public Timer {

public :
  mcAgent *mca;

  MeshRTExchangeCheckTimer (mcAgent *MCA) : Timer() { mca = MCA; };
  void EventHandler (void);

};

class MeshSetupNeighborTimer : public Timer {

public:
  mcAgent *mca; 
  MeshMember *mm; 

  MeshSetupNeighborTimer (mcAgent *MCA, MeshMember *MM) : Timer() { 
    mca = MCA;
    mm = MM;  
  };
  void EventHandler (void); 

}; 

class DataTimer : public Timer {

public :
  mcAgent *mca; 

  DataTimer (mcAgent *MCA) : Timer () {
    mca = MCA; 
  }; 
  void EventHandler (void); 

}; 


//

class StoppedMemberTimer : public Timer {

public :
  mcAgent *mca;

  StoppedMemberTimer (mcAgent *MCA) : Timer () { mca = MCA; };
  void EventHandler (void);

};


class mcAgent : public Agent {

public :

  AgentInfo rp; // The rendezvous point
  //sri's code
  struct MeshRoutingTable meshrt; 
  bool datasource; 
  long data_seq_no; 
  //
  int mesh_refresh_seq_no;

  // Only one MeshMember structure is alloc-ed and is put in both
  // the lists for the neighbors (all_agent_list and mesh_neighbor_list)
  LinkedList <MeshMember *, int> all_agent_list;
  LinkedList <MeshMember *, int> setup_neighbor_list;
  LinkedList <MeshMember *, int> mesh_neighbor_list;

  // These are the members that have stopped sending out refresh messages
  // on the mesh for some time, and are being assumed dead.
  LinkedList <MeshMember *, int> stopped_member_list;

  MeshRefreshTimeoutTimer *mesh_refresh_timer;
  MeshKeepAliveTimer *mesh_keepalive_timer;
  //sri's code
  MeshLinkAddTimer *mesh_link_add_timer;
  MeshRTExchangeTimer *mesh_rt_exchange_timer; 
  MeshLinkDropTimer *mesh_link_drop_timer;
  MeshRTExchangeCheckTimer *mesh_rt_exchange_check_timer; 
  LinkedList <MeshSetupNeighborTimer *, int> mesh_setup_neighbor_timer_list; 
  DataTimer *data_timer; 
  void cleanup_rt(int agentid);
  //
  ~mcAgent (void);
  void start (void);
  void stop (void);
  void init (int Id, int Index, Node *N);

  inline void set_rp_agent(int agent_id, int node_id) { rp.agent_id = agent_id; rp.node_id = node_id; };
  void specific_rx_pkt_handler (Packet *p);  

  void remove_all_agent_list(void);

  void tx_mesh_refresh (void);
  void forward_mesh_refresh (int o_aid, int o_nid, int o_seqno, int except_aid, bool isalive);
  void select_mesh_neighbors (void);
  //sri's code
  void tx_mesh_link_add(void);
  void tx_mesh_rt_exchange(void); 
  void handle_mesh_rt_exchange_timeout(void); 
  void handle_mesh_setup_neighbor_timeout(MeshMember *mm); 
  void tx_mesh_link_drop(void);
  void specific_send_data_pkt(void);
  void tx_data(void); 
  //
  MeshMember * create_new_mesh_member_info (int aid, int nid);
  MeshMember * find_mesh_member_info (int aid);

  void add_to_stopped_member_list (MeshMember *mm);
  void purge_from_stopped_member_list (MeshMember *mm);
  void add_to_setup_neighbor_list (MeshMember *mm);
  void purge_from_setup_neighbor_list (MeshMember *mm);
  void add_to_neighbor_list (MeshMember *mm);
  void purge_from_neighbor_list (MeshMember *mm);

  void remove_mesh_member (int ag_id);

  void tx_mesh_neighbor_setup_req (MeshMember *mm);
  void tx_mesh_neighbor_setup_resp (MeshMember *mm, bool accept);

  void handle_rp_ping_response (AppPacket *ap);
  void handle_mesh_member_refresh (AppPacket *ap);
  //sri's code
  void handle_mesh_rt_exchange (AppPacket *ap);
  void handle_mesh_link_add(AppPacket *ap);
  void handle_mesh_link_add_response(AppPacket *ap);
  void handle_mesh_link_drop(AppPacket *ap);
  void handle_data(AppPacket *ap); 
  //
  void handle_mesh_member_refresh_dead (AppPacket *ap);
  void handle_mesh_member_refresh_alive (AppPacket *ap);
  void handle_mesh_refresh_timeout (void);
  void handle_mesh_neighbor_setup_req (AppPacket *ap);
  void handle_mesh_neighbor_setup_resp (AppPacket *ap);
  void handle_stopped_member_timeout (void);
  double get_time_till_next_transmit (void);

};
#endif