sendmanager.hh

COPE the first practical network coding scheme which is developped on click

#ifndef SENDMANAGER_HH
#define SENDMANAGER_HH

#include <click/element.hh>
#include <click/bighashmap.hh>
#include <click/packet.hh>
#include <clicknet/ether.h>
#include <clicknet/ip.h>
#include <elements/wifi/sr/srpacket.hh>
#include "xorer.hh"

#include <map>
#include <ext/slist>

class EtherAddress;
class IPAddress;

class PacketGID {
public:
  IPAddress _src;
  uint16_t _id;

  PacketGID() : _id(0) {}

  PacketGID(IPAddress src, uint16_t id) : _id(id) { _src = IPAddress(src.addr()); }

  PacketGID(Packet *p) {
    const click_ip *iph = p->ip_header();
    _src = IPAddress(iph->ip_src);
    _id = ntohs(iph->ip_id);
  }
};

inline int hashcode(const PacketGID &pid)
{
  StringAccum sa;
  sa << pid._src << pid._id;
  return hashcode(sa.take_string());
}

inline bool
operator==(const PacketGID &a, const PacketGID &b)
{
  return ((a._src == b._src) && (a._id == b._id));
}

inline bool
operator!=(const PacketGID &a, const PacketGID &b)
{
  return !(a == b);
}

// store a hash of packetgid -> packetstate
// store a hash of packetid -> packetgid

class PacketID {
public:
  EtherAddress _dst;
  uint16_t _seq;

  PacketID(EtherAddress dst, uint16_t seq) : _seq(seq) {
    _dst = EtherAddress(dst.data());
  }

  PacketID(Packet *p) {
    click_ether *eth_p;
    struct srpacket *srh;
    eth_p = (click_ether *)p->data();
    srh = (struct srpacket *)(eth_p + 1);

    _dst = EtherAddress(eth_p->ether_dhost);
    _seq = srh->nseq();
  }

  PacketID() : _seq(0) {}

};

inline int hashcode(const PacketID &pid)
{
  StringAccum sa;
  sa << pid._dst << pid._seq;
  return hashcode(sa.take_string());
}

inline bool
operator==(const PacketID &a, const PacketID &b)
{
  return ((a._seq == b._seq) && (a._dst == b._dst));
}

inline bool
operator!=(const PacketID &a, const PacketID &b)
{
  return !(a == b);
}

#define EVENT_NONE 0
#define EVENT_REXMIT  1
#define EVENT_EXPIRE 2


class SendManager : public Element, public Xorer {
public:
  int do_events(bool);

  inline Packet *take_rexmit_p1() {Packet *x = _rexmit_p1->clone(); _rexmit_p1 = 0; return x;};
  inline Packet *take_rexmit_p2() {Packet *x = _rexmit_p2->clone(); _rexmit_p2 = 0; return x;};
  Packet *take_packet(const PacketGID &);

  void add_new_packet(Packet *, int);
  void add_rexmitted_packet(Packet *, int);
  void register_ack(const PacketID &);
  uint32_t get_next_rexmit_time();

  const char *class_name() const { return "SendManager";}

  int configure(Vector<String> &, ErrorHandler *);
  void *cast(const char *n);

  void add_handlers();
  static String stats(Element *, void *);
  static int static_clear(const String &arg, Element *e, void *, ErrorHandler *errh);
  static int enable_coding(const String &arg, Element *e, void *, ErrorHandler *errh);
  static int rtx_timeout(const String &arg, Element *e, void *, ErrorHandler *errh);
  static int max_xmits(const String &arg, Element *e, void *, ErrorHandler *errh);

  void set_rtx_timeout(unsigned int rtx) {_rtx_timeout = rtx;};
  void set_max_xmits(unsigned int mxmits) {_max_xmits = mxmits;};

  bool _enable_coding;
  // statistics
  int _nacksrecd;

  SendManager();
  ~SendManager();
  
private:

  class PacketState { 
  public:
    bool _acked;  // has this packet been acked
    unsigned char _nxmits; // number of times it has been sent out
    int32_t _rexmit_time; // when is it going to be retransmitted
    bool _timedout; // has the packet timed out before it has been acked

    Packet *_p;   // the actual packet

    PacketState() : _acked(0), _nxmits(1), _rexmit_time(0), _timedout(0), _p(0) {};
    PacketState(Packet *p, int when) : _acked(0), _nxmits(1), _rexmit_time(when), _timedout(0), _p(p) {};

    bool no_more_xmits(const int max_xmits) const { return ((_acked == 1) || (_nxmits == max_xmits)); }
  };

  // keep track of packets I have sent, as they are pulled
  typedef HashMap<PacketGID, PacketState *> SentPackets;
  SentPackets _sentpacks;

  typedef HashMap<PacketID, PacketGID> Nbr2GlobalMap;
  Nbr2GlobalMap _ngm;

  class Event {
  public:
    char _event_type;
    PacketID _pid;
    
    Event() : _event_type(EVENT_NONE) {}
    Event(char e, const PacketID &pid) : _event_type(e), _pid(pid) {}
  };

  typedef __gnu_cxx::slist<Event> EventList;
  

  // stores a map of time to list of events at that time
  typedef std::map<int32_t, EventList *> EventMap;
  EventMap _eventmap;

  Packet *_rexmit_p1;   // first packet in rexmit q
  Packet *_rexmit_p2;   // second packet in rexmit q

  uint32_t _myip;
  unsigned _max_xmits;
  unsigned _rtx_timeout;
  unsigned _exp_timeout;
};

#endif