开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
queuehandle.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：18k
源码类别：

通讯编程

开发平台：

Visual C++

queuehandle.cc：源码内容
  1. /*
  2.  * Copyright (c) 2001 University of Southern California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *      This product includes software developed by the Information Sciences
  16.  *      Institute of the University of Southern California.
  17.  * 4. Neither the name of the University nor of the Institute may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  */
  35. #include <stdlib.h>
  36. #include <math.h>
  37. #ifdef WIN32
  38. #include <windows.h>
  39. #endif
  40. #include "netview.h"
  41. #include "node.h"
  42. #include "edge.h"
  43. #include "paint.h"
  44. #include "sincos.h"
  45. #include "queuehandle.h"
  47. #define PROPERTY_STRING_LENGTH 256
  49. static int g_queuehandle_number = 1;
  51. //----------------------------------------------------------------------
  52. //  Wrapper for creating QueueHandles in OTcl
  53. //----------------------------------------------------------------------
  54. static class QueueHandleClass : public TclClass {
  55. public:
  56.   QueueHandleClass() : TclClass("QueueHandle") {}
  58.   TclObject* create(int argc, const char * const * argv) {
  59.     const char * type;
  60.     int id;
  61.     double size;
  63.     type = argv[4];
  64.     id = strtol(argv[5], NULL, 10);
  65.     size = strtod(argv[6], NULL);
  66.     
  67.     return (new QueueHandle(type, id, size));
  68.   }
  69. } class_queuehandle;
  71. //----------------------------------------------------------------------
  72. //----------------------------------------------------------------------
  73. QueueHandle::QueueHandle(const char* type, int id, double _size) :
  74.   Animation(0, 0) {
  76.   setDefaults();
  77.   number_ = id;
  78.   if (g_queuehandle_number++ <= id) {
  79.     g_queuehandle_number = id + 1;
  80.   }
  82.   width_ = 50.0;
  83.   height_ = size_/2.0;
  85.   size_ = _size;
  86.   size(_size);
  87. }
  89. //----------------------------------------------------------------------
  90. //----------------------------------------------------------------------
  91. QueueHandle::QueueHandle(Edge * edge) :
  92.   Animation(0, 0) {
  93.   Node * node;
  95.   setDefaults();
  96.   edge_ = edge;
  97.   
  98.   number_ = g_queuehandle_number;
  99.   g_queuehandle_number++;
  101.   node = edge_->getSourceNode();
  102.   if (node) {
  103.    size(node->size());
  104.   } else {
  105.    size(10.0);
  106.   }
  108.   limit_ = 20;
  109.   
  110.   // FQ
  111.   secsPerByte_ = 0.0;
  113.   // Stocastic Fair Queue
  114.   maxqueue_ = 40;
  115.   buckets_ = 16;
  117.   // DRR
  118.   blimit_ = 2500;
  119.   quantum_ = 250;
  120.   mask_ = false;
  122.   // RED
  123.   bytes_ = false;
  124.   queue_in_bytes_ = false;
  125.   thresh_ = 5.0;
  126.   maxthresh_ = 15.0;
  127.   mean_pktsize_ = 500;
  128.   q_weight_ = 0.002;
  129.   wait_ = false;
  130.   linterm_ = 30.0;
  131.   setbit_ = false;
  132.   drop_tail_ = false;
  133. }
  135. //----------------------------------------------------------------------
  136. //----------------------------------------------------------------------
  137. void
  138. QueueHandle::setDefaults() {
  139.   next_queue_handle_ = NULL;
  140.   edge_ = NULL;
  142.   x_ = 0.0;
  143.   y_ = 0.0;
  144.   angle_ = NO_ANGLE;
  145.   color_ = "black";
  146.   paint_ = Paint::instance()->thin();
  147.   width_ = 10.0;
  148.   height_ = 10.0;
  150.   type_ = NULL;
  151.   ns_type_ = NULL;
  152.   setType("DropTail");
  153. }
  155. //----------------------------------------------------------------------
  156. // double 
  157. // QueueHandle::distance(double x, double y) const {
  158. //----------------------------------------------------------------------
  159. double
  160. QueueHandle::distance(double x, double y) const {
  161.   return sqrt((x_-x)*(x_-x) + (y_-y)*(y_-y));
  162. }
  164. //----------------------------------------------------------------------
  165. //----------------------------------------------------------------------
  166. void
  167. QueueHandle::color(const char * name) {
  168.   if (color_) {
  169.     delete []color_;
  170.   }
  171.   color_ = new char[strlen(name) + 1];
  172.   strcpy(color_, name);
  173. }
  175. //----------------------------------------------------------------------
  176. //----------------------------------------------------------------------
  177. void QueueHandle::size(double s) {
  178.   size_ = s;
  179.   width_ = 10.0 + 25.0;
  180.   height_ = s/2.0;
  181.   update_bb();
  182. }
  184. //----------------------------------------------------------------------
  185. //----------------------------------------------------------------------
  186. void QueueHandle::update_bb() {
  187.   bb_.xmin = x_;
  188.   bb_.ymin = y_;
  189.   bb_.xmax = x_ + width_;
  190.   bb_.ymax = y_ + height_;
  191. }
  193. //----------------------------------------------------------------------
  194. //----------------------------------------------------------------------
  195. void QueueHandle::setType(const char* type) {
  196.         const char * expanded_type;
  198.         // Expand Ns Type Names 
  199. if (!strcmp(type, "FQ")) {
  200.           expanded_type = "FairQueue";
  201. } else if (!strcmp(type, "SFQ")) {
  202.           expanded_type = "StocasticFairQueue";
  203. } else if (!strcmp(type, "DRR")) {
  204.           expanded_type = "DeficitRoundRobin";
  205.         } else {
  206.           expanded_type = type;
  207.         }
  209.   
  210.         // Deleted existing type strings
  211. if (type_) {
  212. delete[] type_;
  213. }
  214. if (ns_type_) {
  215. delete[] ns_type_;
  216. ns_type_ = NULL;
  217. }
  219.         // Set type and ns type to new strings
  220. type_ = new char[strlen(expanded_type) + 1];
  221. strcpy(type_, expanded_type);
  223. if (!strcmp(expanded_type, "DropTail")) {
  224. ns_type_ = new char[strlen("DropTail") + 1];
  225. strcpy(ns_type_, "DropTail");
  226. } else if (!strcmp(expanded_type, "FairQueue")) {
  227. ns_type_ = new char[strlen("FQ") + 1];
  228. strcpy(ns_type_, "FQ");
  229. } else if (!strcmp(expanded_type, "StocasticFairQueue")) {
  230. ns_type_ = new char[strlen("SFQ") + 1];
  231. strcpy(ns_type_, "SFQ");
  232. } else if (!strcmp(expanded_type, "DeficitRoundRobin")) {
  233. ns_type_ = new char[strlen("DRR") + 1];
  234. strcpy(ns_type_, "DRR");
  235. } else if (!strcmp(expanded_type, "RED")) {
  236. ns_type_ = new char[strlen("RED") + 1];
  237. strcpy(ns_type_, "RED");
  238. }
  239. }
  241. //----------------------------------------------------------------------
  242. //----------------------------------------------------------------------
  243. void QueueHandle::reset(double) {
  244.   paint_ = Paint::instance()->thick();
  245. }
  247. //----------------------------------------------------------------------
  248. // void
  249. // QueueHandle::attach(Agent * agent)
  250. //----------------------------------------------------------------------
  251. void
  252. QueueHandle::attachTo(Edge * edge) {
  253.   edge_ = edge; 
  254.   place();
  255. }
  257. //----------------------------------------------------------------------
  258. //----------------------------------------------------------------------
  259. void QueueHandle::clearEdge() {
  260.   edge_ = NULL;
  261. }
  263. //----------------------------------------------------------------------
  264. // void
  265. // QueueHandle::place()  
  266. //----------------------------------------------------------------------
  267. void
  268. QueueHandle::place() {
  269. double sine, cosine, angle;
  271. if (edge_) {
  272. angle = edge_->angle();
  273. sine = sin(angle);
  274. cosine = cos(angle);
  276. if ((angle > 0.0 && angle < M_PI/2.0) ||
  277.     (angle < M_PI/-2.0 && angle > -1.0*M_PI)) {
  278. x_ = edge_->x() + cosine * height_;
  279. y_ = edge_->y() + sine * height_ - height_;
  280. } else {
  281. x_ = edge_->x() + cosine * height_;
  282. y_ = edge_->y() + sine * height_;
  283. }
  285. }
  286.      update_bb();
  287. }
  290. //----------------------------------------------------------------------
  291. //----------------------------------------------------------------------
  292. const char* QueueHandle::info() const {
  293.   static char text[128];
  295.   sprintf(text, "Queue Type: %s %d->%d", type_, edge_->src(), edge_->dst());
  296.   return (text);
  297. }
  300. //----------------------------------------------------------------------
  301. // int 
  302. // QueueHandle::inside(double, float px, float py) const 
  303. //   - Check to see if point (px, py) is within the Loss Model box
  304. //----------------------------------------------------------------------
  305. int 
  306. QueueHandle::inside(double, float px, float py) const {
  307.   return (px >= x_ && 
  308.           px <= (x_ + width_) &&
  309.           py >= y_ && 
  310.           py <= (y_ + height_));
  311. }
  313. //----------------------------------------------------------------------
  314. // void
  315. // QueueHandle::draw(View * view, double ) const
  316. //   - Draw the Loss Model on its edge
  317. //----------------------------------------------------------------------
  318. void
  319. QueueHandle::draw(View * view, double time) {
  320. double label_width, label_height, label_x, label_y;
  321. char * label = "Q";
  323. if (edge_) {
  325. // Draw label centered inside of border
  326. // We have to keep calculting the label width and height because
  327. // we have no way of knowing if the user has zoomed in or out 
  328. // on the current network view.
  329. label_height = 0.9 * height_;
  330. label_width = view->getStringWidth(label, label_height);
  332. // Add 10% of padding to width for the box
  333. setWidth(1.1 * label_width);
  335. // Center label in box
  336. label_x = x_ + (width_ - label_width);
  337. label_y = y_ + (height_ - label_height);
  339. view->string(label, label_x , label_y, label_height, NULL);
  341. update_bb();
  343. // Draw Rectangle Border
  344. view->rect(x_, y_, x_ + width_, y_ + height_ , paint_);
  345. }
  346. }
  348. //----------------------------------------------------------------------
  349. // int
  350. // QueueHandle::writeNsScript(FILE * file)
  351. //  - outputs ns script format for creating loss models
  352. //----------------------------------------------------------------------
  353. int
  354. QueueHandle::writeNsScript(FILE * file) {
  355. if (edge_) {
  356. fprintf(file, "# Set Queue Properties for link %d->%dn", edge_->src(), edge_->dst());
  357. if (!strcmp(type_, "DropTail")) {
  358. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set limit_ %dn", edge_->src(), edge_->dst(), limit_);
  360. } else if (!strcmp(type_, "FairQueue")) {
  361. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set secsPerByte_ %fn", edge_->src(), edge_->dst(), secsPerByte_);
  362. } else if (!strcmp(type_, "StocasticFairQueue")) {
  363. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set maxqueue_ %dn", edge_->src(), edge_->dst(), maxqueue_);
  364. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set buckets_ %dn", edge_->src(), edge_->dst(), buckets_);
  365. } else if (!strcmp(type_, "DeficitRoundRobin")) {
  366. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set buckets_ %dn", edge_->src(), edge_->dst(), buckets_);
  367. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set blimit_ %dn", edge_->src(), edge_->dst(), blimit_);
  368. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set quantum_ %dn", edge_->src(), edge_->dst(), quantum_);
  369.                         if (mask_) {
  370.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set mask_ 1n", edge_->src(), edge_->dst());
  371.                         }
  372. } else if (!strcmp(type_, "RED")) {
  373.                         if (bytes_) {
  374.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set bytes_ 1n", edge_->src(), edge_->dst());
  375.                         }
  376.                         if (queue_in_bytes_) {
  377.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set queue_in_bytes_ 1n", edge_->src(), edge_->dst());
  378.                         }
  379. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set thresh_ %fn", edge_->src(), edge_->dst(), thresh_);
  380. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set maxthresh_ %fn", edge_->src(), edge_->dst(), maxthresh_);
  381. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set mean_pktsize_ %dn", edge_->src(), edge_->dst(), mean_pktsize_);
  382. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set q_weight_ %fn", edge_->src(), edge_->dst(), q_weight_);
  383.                         if (wait_) {
  384.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set queue_in_bytes_ 1n", edge_->src(), edge_->dst());
  385.                         }
  386. fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set linterm_ %fn", edge_->src(), edge_->dst(), linterm_);
  387.                         if (setbit_) {
  388.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set setbit_ 1n", edge_->src(), edge_->dst());
  389.                         }
  390.                         if (queue_in_bytes_) {
  391.         fprintf(file, "[[$ns link $node(%d) $node(%d)] queue] set drop_tail_ 1n", edge_->src(), edge_->dst());
  392.                         }
  393. }
  394. }
  396.   return 0;
  397. }
  399. //----------------------------------------------------------------------
  400. // QueueHandle::property()
  401. //   - return the list of queue configuration parameters
  402. //     (properties) to be shown in the property edit window
  403. //----------------------------------------------------------------------
  404. const char*
  405. QueueHandle::property() {
  406.   return getProperties(type_);
  407. }
  408.   
  409. //----------------------------------------------------------------------
  410. // QueueHandle::property()
  411. //   - return the list of queue configuration parameters
  412. //     (properties) to be shown in the property edit window
  413. //   - This is used if the queue type is changed to a different type
  414. //     so we can give the properties related to that specific type of 
  415. //     queue to which we have switched 
  416. //----------------------------------------------------------------------
  417. const char *
  418. QueueHandle::getProperties(char * type) {
  419.   static char text[PROPERTY_STRING_LENGTH];
  420.   char * property_list;
  421.   int total_written = 0;
  423.   // object type, id and header info
  424.   property_list = text;
  425.   total_written = sprintf(text,
  426.           "{"Queue: %s %d->%d" title title "QueueHandle %d-%d"} ",
  427.           type_, edge_->src(), edge_->dst(), edge_->src(), edge_->dst());
  429.   property_list = &text[strlen(text)];
  430.   sprintf(property_list, "{"Queue Type" type_ drop_down_list {{%s} {DropTail FairQueue StocasticFairQueue DeficitRoundRobin RED}}} ", type);
  432.   if (strcmp(type, "DropTail") == 0) {
  433.     property_list = &text[strlen(text)];
  434.     sprintf(property_list, "{"Maximum Queue Size" limit_ text %d} ",
  435.                            limit_);
  437.   } else if (strcmp(type, "FairQueue") == 0) {
  438.     property_list = &text[strlen(text)];
  439.     sprintf(property_list, "{"Seconds Per Byte" secsPerByte_ text %f} ",
  440.                            secsPerByte_); 
  442.   } else if (strcmp(type, "StocasticFairQueue") == 0) {
  443.     property_list = &text[strlen(text)];
  444.     sprintf(property_list, "{"Maximum Queue Size" maxqueue_ text %d} ",
  445.                            maxqueue_);
  446.     property_list = &text[strlen(text)];
  447.     sprintf(property_list, "{"Number of Buckets" buckets_ text %d} ",
  448.                            buckets_);
  450.   } else if (strcmp(type, "DeficitRoundRobin") == 0) {
  451.     property_list = &text[strlen(text)];
  452.     sprintf(property_list, "{"Number of Buckets" buckets_ text %d} ",
  453.                            buckets_);
  454.     property_list = &text[strlen(text)];
  455.     sprintf(property_list, "{"Shared Buffer Size" blimit_ text %d} ",
  456.                            blimit_);
  457.     property_list = &text[strlen(text)];
  458.     sprintf(property_list, "{"Flow Quantum" quantum_ text %d} ",
  459.                            quantum_);
  460.     property_list = &text[strlen(text)];
  461.     sprintf(property_list, "{"Exclude Port Number from Flow Identification" mask_ checkbox %d} ",
  462.                            mask_);
  465.   } else if (strcmp(type, "RED") == 0) {
  466.     property_list = &text[strlen(text)];
  467.     sprintf(property_list, "{"Enable Byte Mode RED" bytes_ checkbox %d} ",
  468.                            bytes_);
  469.     property_list = &text[strlen(text)];
  470.     sprintf(property_list, "{"Queue in Bytes" queue_in_bytes_ checkbox %d} ",
  471.                            queue_in_bytes_);
  472.     property_list = &text[strlen(text)];
  473.     sprintf(property_list, "{"Wait Interval Between Drops" wait_ checkbox %d} ",
  474.                            wait_);
  475.     property_list = &text[strlen(text)];
  476.     sprintf(property_list, "{"Mark Packets for Congestion Instead of Dropping" setbit_ checkbox %d} ",
  477.                            setbit_);
  478.     property_list = &text[strlen(text)];
  479.     sprintf(property_list, "{"Use Drop Tail instead of Random Drop" drop_tail_ checkbox %d} ",
  480.                            drop_tail_);
  482.     property_list = &text[strlen(text)];
  483.     sprintf(property_list, "{"Minimum Threshhold for Average Queue Size" thresh_ text %g} ", 
  484.                            thresh_); 
  485.     property_list = &text[strlen(text)];
  486.     sprintf(property_list, "{"Maximum Threshhold for Average Queue Size" maxthresh_ text %g} ", 
  487.                            maxthresh_);
  488.     property_list = &text[strlen(text)];
  489.     sprintf(property_list, "{"Estimate for Average Queue Size" mean_pktsize_ text %d} ", 
  490.                            mean_pktsize_);
  491.     property_list = &text[strlen(text)];
  492.     sprintf(property_list, "{"Queue Weight" q_weight_ text %g} ", 
  493.                            q_weight_);
  494.     property_list = &text[strlen(text)];
  495.     sprintf(property_list, "{"Maximum Drop Probability (1/linterm_)" linterm_ text %g} ", 
  496.                            linterm_);
  497.   }
  499.   return(text);
  500. }
  503. //----------------------------------------------------------------------
  504. //----------------------------------------------------------------------
  505. int QueueHandle::command(int argc, const char * const * argv) {
  506.   return TCL_OK;
  507. }