forest-net
an overlay networks for large-scale virtual worlds
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator
QuManager.h
1 
9 #ifndef QUMANAGER_H
10 #define QUMANAGER_H
11 
12 #include <chrono>
13 #include <thread>
14 #include <mutex>
15 
16 #include "Forest.h"
20 inline ostream& operator<<(ostream& out,
21  const chrono::high_resolution_clock::time_point& t) {
22  return out << t.time_since_epoch().count();
23 }
24 
25 #include "ListSet.h"
26 #include "Dheap.h"
27 #include "DheapSet.h"
28 #include "PacketStore.h"
29 #include "StatsModule.h"
30 
31 using namespace chrono;
32 using std::thread;
33 using std::mutex;
34 using std::unique_lock;
35 
36 namespace forest {
37 
38 
47 class QuManager {
48 public:
49  QuManager(int,int,int,int,PacketStore*,StatsModule*);
50  ~QuManager();
51 
52  // predicates
53  bool validQ(int) const;
54 
55  // allocate/free queues
56  int allocQ(int);
57  void freeQ(int);
58 
59  // set queue rates and length limits
60  bool setLinkRates(int,RateSpec&);
61  bool setQRates(int,RateSpec&);
62  bool setQLimits(int,int,int);
63 
64  // enq and deq packets
65  bool enq(int, int, uint64_t);
66  int deq(int&, uint64_t);
67 
68 private:
69  int nL;
70  int nP;
71  int nQ;
72  int maxppl;
73  int qCnt;
74 
75  ListSet *queues;
76  int free;
77  Dheap<uint64_t> *active;
78  Dheap<uint64_t> *vactive;
79 
80  mutex mtx;
81 
82  struct LinkInfo {
83  uint32_t nsPerByte;
84  uint32_t minDelta;
85  uint64_t avgPktTime;
86  uint64_t vt;
87  };
88  LinkInfo *lnkInfo;
89 
90  struct QuInfo {
91  int lnk;
92  uint32_t nsPerByte;
93  uint32_t minDelta;
94  int pktLim;
95  int byteLim;
96  uint64_t vft;
97  };
98  QuInfo *quInfo;
99 
100  DheapSet<uint64_t> *hset;
101 
102  PacketStore *ps;
103  StatsModule *sm;
104 };
105 
106 
107 inline bool QuManager::validQ(int qid) const {
108  unique_lock lck(mtx);
109  return 1 <= qid && qid <= nQ && quInfo[qid].pktLim >= 0;
110 }
111 
112 inline bool QuManager::setLinkRates(int lnk, RateSpec& rs) {
113  unique_lock lck(mtx);
114  if (lnk < 1 || lnk > nL) return false;
115  int br = max(rs.bitRateDown,1);
116  int pr = max(rs.pktRateDown,1);
117  br = min(br,8000000); pr = min(pr,1000000000);
118  lnkInfo[lnk].nsPerByte = 8000000/br;
119  lnkInfo[lnk].minDelta = 1000000000/pr;
120  return true;
121 }
122 
123 inline bool QuManager::setQRates(int qid, RateSpec& rs) {
124  unique_lock lck(mtx);
125  if (!validQ(qid)) return false;
126  int br = min(rs.bitRateDown,8000000);
127  int pr = min(rs.pktRateDown,1000000000);
128  quInfo[qid].nsPerByte = 8000000/br;
129  quInfo[qid].minDelta = 1000000000/pr;
130  return true;
131 }
132 
133 inline bool QuManager::setQLimits(int qid, int np, int nb) {
134  unique_lock lck(mtx);
135  if (!validQ(qid)) return false;
136  np = max(0,np); nb = max(0,nb);
137  quInfo[qid].pktLim = np;
138  quInfo[qid].byteLim = nb;
139  return true;
140 }
141 
142 } // ends namespace
143 
144 
145 #endif