00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef _PROPHET_QUEUE_POLICY_H_
00018 #define _PROPHET_QUEUE_POLICY_H_
00019
00020 #include "Bundle.h"
00021 #include "Table.h"
00022 #include "Stats.h"
00023
00024 #include <string>
00025
00026 namespace prophet
00027 {
00028
00029
00030 class QueueComp;
00031
00032 struct QueuePolicy
00033 {
00038 typedef enum {
00039 INVALID_QP = 0,
00040 FIFO,
00041 MOFO,
00042 MOPR,
00043 LINEAR_MOPR,
00044 SHLI,
00045 LEPR
00046 } q_policy_t;
00047
00051 static const char*
00052 qp_to_str(q_policy_t qp)
00053 {
00054 switch(qp) {
00055 #define CASE(_q_p) case _q_p: return # _q_p
00056 CASE(FIFO);
00057 CASE(MOFO);
00058 CASE(MOPR);
00059 CASE(LINEAR_MOPR);
00060 CASE(SHLI);
00061 CASE(LEPR);
00062 #undef CASE
00063 default: return "Unknown queuing policy";
00064 }
00065 }
00066
00067 static q_policy_t
00068 str_to_qp(const char* str)
00069 {
00070 std::string qp(str);
00071 if (qp == "FIFO")
00072 return FIFO;
00073 if (qp == "MOFO")
00074 return MOFO;
00075 if (qp == "MOPR")
00076 return MOPR;
00077 if (qp == "LINEAR_MOPR")
00078 return LINEAR_MOPR;
00079 if (qp == "SHLI")
00080 return SHLI;
00081 if (qp == "LEPR")
00082 return LEPR;
00083 return INVALID_QP;
00084 }
00085
00093 static inline QueueComp* policy(q_policy_t qp,
00094 const Stats* stats = NULL,
00095 const Table* nodes = NULL,
00096 u_int min_forward = 0);
00097
00098 };
00099
00104 class QueueComp
00105 {
00106 public:
00110 virtual ~QueueComp() {}
00111
00115 virtual bool operator() (const Bundle* a, const Bundle* b) const
00116 {
00117 if (verbose_)
00118 printf("FIFO: %u:%u %s %u:%u\n",
00119 b->creation_ts(),
00120 b->sequence_num(),
00121 (*b < *a) ? "<" : "!<",
00122 a->creation_ts(),
00123 a->sequence_num());
00124 return *b < *a;
00125 }
00126
00128 QueuePolicy::q_policy_t qp() const { return qp_; }
00129 const Stats* stats() const { return stats_; }
00130 const Table* nodes() const { return nodes_; }
00132
00133 protected:
00134 friend class QueuePolicy;
00135
00139 QueueComp(QueuePolicy::q_policy_t qp = QueuePolicy::INVALID_QP,
00140 const Stats* stats = NULL, const Table* nodes = NULL,
00141 u_int minfwd = 0)
00142 : qp_(qp),
00143 stats_(stats),
00144 nodes_(nodes),
00145 min_fwd_(minfwd),
00146 verbose_(false) {}
00147
00148 QueuePolicy::q_policy_t qp_;
00149 const Stats* stats_;
00150 const Table* nodes_;
00151
00152 public:
00153 u_int min_fwd_;
00154
00155 bool verbose_;
00156 };
00157
00161 class QueueCompMOFO : public QueueComp
00162 {
00163 public:
00167 virtual ~QueueCompMOFO() {}
00168
00172 virtual bool operator() (const Bundle* a, const Bundle* b) const
00173 {
00174
00175 if (verbose_)
00176 printf("MOFO: %d (%d) %s %d (%d)\n",
00177 a->sequence_num(),
00178 a->num_forward(),
00179 (a->num_forward() < b->num_forward()) ? ">" : "<",
00180 b->sequence_num(),
00181 b->num_forward());
00182 return a->num_forward() < b->num_forward();
00183 }
00184
00185 protected:
00186 friend class QueuePolicy;
00187
00191 QueueCompMOFO(QueuePolicy::q_policy_t qp)
00192 : QueueComp(qp) {}
00193 };
00194
00198 class QueueCompMOPR : public QueueComp
00199 {
00200 public:
00204 virtual ~QueueCompMOPR() {}
00205
00209 virtual bool operator() (const Bundle* a, const Bundle* b) const
00210 {
00211
00212 if (verbose_)
00213 printf("MOPR: %d (%.2f) %s %d (%.2f)\n",
00214 a->sequence_num(),
00215 stats_->get_mopr(a),
00216 (stats_->get_mopr(a) < stats_->get_mopr(b)) ? "<" : "!<",
00217 b->sequence_num(),
00218 stats_->get_mopr(b));
00219 return stats_->get_mopr(a) < stats_->get_mopr(b);
00220 }
00221
00222 protected:
00223 friend class QueuePolicy;
00224
00228 QueueCompMOPR(QueuePolicy::q_policy_t qp, const Stats* stats)
00229 : QueueComp(qp,stats) {}
00230 };
00231
00235 class QueueCompLMOPR : public QueueComp
00236 {
00237 public:
00241 virtual ~QueueCompLMOPR() {}
00242
00246 virtual bool operator() (const Bundle* a, const Bundle* b) const
00247 {
00248
00249 if (verbose_)
00250 printf("LMOPR: %d (%.2f) %s %d (%.2f)\n",
00251 a->sequence_num(),
00252 stats_->get_lmopr(a),
00253 (stats_->get_lmopr(a) < stats_->get_lmopr(b)) ? "<" : "!<",
00254 b->sequence_num(),
00255 stats_->get_lmopr(b));
00256 return stats_->get_lmopr(a) < stats_->get_lmopr(b);
00257 }
00258
00259 protected:
00260 friend class QueuePolicy;
00261
00265 QueueCompLMOPR(QueuePolicy::q_policy_t qp, const Stats* stats)
00266 : QueueComp(qp,stats) {}
00267 };
00268
00272 class QueueCompSHLI : public QueueComp
00273 {
00274 public:
00278 virtual ~QueueCompSHLI() {}
00279
00283 virtual bool operator() (const Bundle* a, const Bundle* b) const
00284 {
00285
00286
00287
00288 u_int32_t ae = a->creation_ts() + a->expiration_ts();
00289 u_int32_t be = b->creation_ts() + b->expiration_ts();
00290
00291 if (verbose_)
00292 printf("SHLI: %d (%d) %s %d (%d)\n",
00293 a->sequence_num(),
00294 ae,
00295 (ae > be) ? ">" : "!>",
00296 b->sequence_num(),
00297 be);
00298 return ae > be;
00299 }
00300
00301 protected:
00302 friend class QueuePolicy;
00303
00307 QueueCompSHLI(QueuePolicy::q_policy_t qp)
00308 : QueueComp(qp) {}
00309 };
00310
00314 class QueueCompLEPR : public QueueComp
00315 {
00316 public:
00320 virtual ~QueueCompLEPR() {}
00321
00325 virtual bool operator() (const Bundle* a, const Bundle* b) const
00326 {
00327
00328 if (verbose_)
00329 printf("LEPR: %d (%.2f) %s %d (%.2f)\n",
00330 a->sequence_num(),
00331 nodes_->p_value(a),
00332 (nodes_->p_value(b) < nodes_->p_value(a)) ? ">" : "<",
00333 b->sequence_num(),
00334 nodes_->p_value(b));
00335 return nodes_->p_value(b) < nodes_->p_value(a);
00336 }
00337
00338 protected:
00339 friend class QueuePolicy;
00340
00344 QueueCompLEPR(QueuePolicy::q_policy_t qp,
00345 const Table* nodes,
00346 u_int min_forward)
00347 : QueueComp(qp,NULL,nodes,min_forward) {}
00348 };
00349
00350 QueueComp*
00351 QueuePolicy::policy(QueuePolicy::q_policy_t qp,
00352 const Stats* stats, const Table* nodes,
00353 u_int min_forward)
00354 {
00355 (void) stats;
00356 (void) nodes;
00357 switch (qp)
00358 {
00359
00360
00361 case QueuePolicy::FIFO:
00362 return new QueueComp(qp);
00363
00364
00365 case QueuePolicy::MOFO:
00366 return new QueueCompMOFO(qp);
00367
00368
00369 case QueuePolicy::MOPR:
00370 {
00371 if (stats == NULL) return NULL;
00372 return new QueueCompMOPR(qp,stats);
00373 }
00374
00375
00376 case QueuePolicy::LINEAR_MOPR:
00377 {
00378 if (stats == NULL) return NULL;
00379 return new QueueCompLMOPR(qp,stats);
00380 }
00381
00382
00383 case QueuePolicy::SHLI:
00384 return new QueueCompSHLI(qp);
00385
00386
00387 case QueuePolicy::LEPR:
00388 {
00389 if (min_forward == 0 || nodes == NULL) return NULL;
00390 return new QueueCompLEPR(qp,nodes,min_forward);
00391 }
00392
00393
00394 case QueuePolicy::INVALID_QP:
00395 default:
00396 return NULL;
00397 }
00398 }
00399
00400 };
00401
00402 #endif // _PROPHET_QUEUE_POLICY_H_