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

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

通讯编程

开发平台：

Visual C++

queue-monitor.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  * 
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  *      This product includes software developed by the MASH Research
  17.  *      Group at the University of California Berkeley.
  18.  * 4. Neither the name of the University nor of the Research Group may be
  19.  *    used to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  * 
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  35. #ifndef lint
  36. static const char rcsid[] =
  37.     "@(#) $Header: /cvsroot/nsnam/ns-2/tools/queue-monitor.cc,v 1.29 2004/10/28 01:21:41 sfloyd Exp $";
  38. #endif
  40. #include "queue-monitor.h"
  41. #include "trace.h"
  42. #include <math.h>
  44. int QueueMonitor::command(int argc, const char*const* argv)
  45. {
  46. Tcl& tcl = Tcl::instance();
  48. if (argc == 2) {
  49. if (strcmp(argv[1], "get-bytes-integrator") == 0) {
  50. if (bytesInt_)
  51. tcl.resultf("%s", bytesInt_->name());
  52. else
  53. tcl.resultf("");
  54. return (TCL_OK);
  55. }
  56. if (strcmp(argv[1], "get-pkts-integrator") == 0) {
  57. if (pktsInt_)
  58. tcl.resultf("%s", pktsInt_->name());
  59. else
  60. tcl.resultf("");
  61. return (TCL_OK);
  62. }
  63. if (strcmp(argv[1], "get-delay-samples") == 0) {
  64. if (delaySamp_)
  65. tcl.resultf("%s", delaySamp_->name());
  66. else
  67. tcl.resultf("");
  68. return (TCL_OK);
  69. }
  70. if (strcmp(argv[1], "printRTTs") == 0) {
  71. if (keepRTTstats_ && channel1_) {
  72. printRTTs();
  73. } 
  74. return (TCL_OK);
  75. }
  76. if (strcmp(argv[1], "printSeqnos") == 0) {
  77. if (keepSeqnoStats_ && channel1_) {
  78. printSeqnos();
  79. } 
  80. return (TCL_OK);
  81. }
  82. }
  84. if (argc == 3) {
  85. if (strcmp(argv[1], "set-bytes-integrator") == 0) {
  86. bytesInt_ = (Integrator *)
  87. TclObject::lookup(argv[2]);
  88. if (bytesInt_ == NULL)
  89. return (TCL_ERROR);
  90. return (TCL_OK);
  91. }
  92. if (strcmp(argv[1], "set-pkts-integrator") == 0) {
  93. pktsInt_ = (Integrator *)
  94. TclObject::lookup(argv[2]);
  95. if (pktsInt_ == NULL)
  96. return (TCL_ERROR);
  97. return (TCL_OK);
  98. }
  99. if (strcmp(argv[1], "set-delay-samples") == 0) {
  100. delaySamp_ = (Samples*)
  101. TclObject::lookup(argv[2]);
  102. if (delaySamp_ == NULL)
  103. return (TCL_ERROR);
  104. return (TCL_OK);
  105. }
  106. if (strcmp(argv[1], "trace") == 0) {
  107. // for printStats
  108. int mode;
  109. const char* id = argv[2];
  110. channel_ = Tcl_GetChannel(tcl.interp(), (char*)id, &mode);
  111. if (channel_ == 0) {
  112. tcl.resultf("trace: can't attach %s for writing", id);
  113. return (TCL_ERROR);
  114. }
  115. return (TCL_OK);
  116. }
  117. if (strcmp(argv[1], "traceDist") == 0) {
  118. // for printRTTs and printSeqnos distributions
  119. int mode;
  120. const char* id = argv[2];
  121. channel1_ = Tcl_GetChannel(tcl.interp(), (char*)id, &mode);
  122. if (channel1_ == 0) {
  123. tcl.resultf("trace: can't attach %s for writing", id);
  124. return (TCL_ERROR);
  125. }
  126. return (TCL_OK);
  127. }
  128. }
  129. if (argc == 4) {
  130. if (strcmp(argv[1], "set-src-dst") == 0) {
  131. srcId_ = atoi(argv[2]);
  132. dstId_ = atoi(argv[3]);
  133. return (TCL_OK);
  134. }
  135. }
  136. return TclObject::command(argc, argv); // else control reaches end of
  137. // non-void function, see? :-)
  138. }
  140. static class QueueMonitorClass : public TclClass {
  141.  public:
  142. QueueMonitorClass() : TclClass("QueueMonitor") {}
  143. TclObject* create(int, const char*const*) {
  144. return (new QueueMonitor());
  145. }
  146. } queue_monitor_class;
  149. void
  150. QueueMonitor::printRTTs() {
  151. int i, n, topBin, MsPerBin;
  152. char wrk[500];
  154. topBin = maxRTT_ * binsPerSec_;
  155. MsPerBin = int(1000/binsPerSec_);
  156. double now = Scheduler::instance().clock();
  157. sprintf(wrk, "Distribution of RTTs, %d ms bins, time %4.2fn", MsPerBin, now);
  158. n = strlen(wrk); wrk[n] = 0;
  159. (void)Tcl_Write(channel1_, wrk, n);
  160. for (i = 0; i < topBin; i++) {
  161. if (RTTbins_[i] > 0) {
  162.     sprintf(wrk, "%d to %d ms: frac %5.3f num %d time %4.2fn", 
  163.       i*MsPerBin, (i+1)*MsPerBin, 
  164.   (double)RTTbins_[i]/numRTTs_,
  165.       RTTbins_[i], now); 
  166. n = strlen(wrk); wrk[n] = 0; 
  167. (void)Tcl_Write(channel1_, wrk, n);
  168. }
  169. }
  170. i = topBin - 1;
  171. if (RTTbins_[i] > 0) {
  172. sprintf(wrk, "The last bin might also contain RTTs >= %d ms.n",
  173. (i+1)*MsPerBin);
  174. n = strlen(wrk); wrk[n] = 0;
  175. (void)Tcl_Write(channel1_, wrk, n);
  176. }
  177. }
  179. void
  180. QueueMonitor::printSeqnos() {
  181. int i, n, topBin; 
  182. char wrk[500];
  184. topBin = int(maxSeqno_ / SeqnoBinSize_);
  185. double now = Scheduler::instance().clock();
  186. sprintf(wrk, "Distribution of Seqnos, %d seqnos per bin, time %4.2fn", 
  187.    SeqnoBinSize_, now);
  188.   n = strlen(wrk); wrk[n] = 0;
  189. (void)Tcl_Write(channel1_, wrk, n);
  190. for (i = 0; i < topBin; i++) {
  191. if (SeqnoBins_[i] > 0) {
  192.     sprintf(wrk, "%d to %d seqnos: frac %5.3f num %d time %4.2fn", 
  193.       i*SeqnoBinSize_, (i+1)*SeqnoBinSize_ - 1, 
  194.   (double)SeqnoBins_[i]/numSeqnos_,
  195.       SeqnoBins_[i], now); 
  196. n = strlen(wrk); wrk[n] = 0;
  197. (void)Tcl_Write(channel1_, wrk, n);
  198. }
  199. }
  200. i = topBin - 1;
  201. if (SeqnoBins_[i] > 0) {
  202. sprintf(wrk, "The last bin might also contain Seqnos >= %d. n",
  203. (i+1)*SeqnoBinSize_);
  204. n = strlen(wrk); wrk[n] = 0;
  205. (void)Tcl_Write(channel1_, wrk, n);
  206. }
  207. }
  209. void
  210. QueueMonitor::printStats() {
  211. char wrk[500];
  212. int n;
  213. double now = Scheduler::instance().clock();
  214. sprintf(wrk, "q -t "TIME_FORMAT" -s %d -d %d -l %d -p %d", now, srcId_, dstId_, size_, pkts_);
  215. n = strlen(wrk);
  216. wrk[n] = 'n';
  217. wrk[n+1] = 0;
  218. (void)Tcl_Write(channel_, wrk, n+1);
  219. wrk[n] = 0;
  220. }
  222. // packet arrival to a queue
  223. void QueueMonitor::in(Packet* p)
  224. {
  225. hdr_cmn* hdr = hdr_cmn::access(p);
  226. double now = Scheduler::instance().clock();
  227. int pktsz = hdr->size();
  228. hdr_flags* pf = hdr_flags::access(p);
  230. last_pkt_ = Scheduler::instance().clock();
  231. if (parrivals_ == 0) {
  232. first_pkt_ = last_pkt_;
  233. }
  235. if (pf->qs()) {
  236. qs_pkts_++;
  237. qs_bytes_ += pktsz;
  238. }
  240.         //if enabled estimate rate now
  241. if (estimate_rate_) {
  242. estimateRate(p);
  243. }
  244. else {
  245. prevTime_ = now;
  246. }
  248. barrivals_ += pktsz;
  249. parrivals_++;
  250. size_ += pktsz;
  251. pkts_++;
  252. if (bytesInt_)
  253. bytesInt_->newPoint(now, double(size_));
  254. if (pktsInt_)
  255. pktsInt_->newPoint(now, double(pkts_));
  256. if (delaySamp_)
  257. hdr->timestamp() = now;
  258. if (channel_)
  259. printStats();
  261. }
  263. void QueueMonitor::out(Packet* p)
  264. {
  265. hdr_cmn* hdr = hdr_cmn::access(p);
  266. hdr_flags* pf = hdr_flags::access(p);
  267. double now = Scheduler::instance().clock();
  268. int pktsz = hdr->size();
  270. if (pf->ce() && pf->ect()) 
  271. pmarks_++;
  272. size_ -= pktsz;
  273. pkts_--;
  274. bdepartures_ += pktsz;
  275. pdepartures_++;
  276. if (bytesInt_)
  277. bytesInt_->newPoint(now, double(size_));
  278. if (pktsInt_)
  279. pktsInt_->newPoint(now, double(pkts_));
  280. if (delaySamp_)
  281. delaySamp_->newPoint(now - hdr->timestamp());
  283.         if (keepRTTstats_) {
  284. keepRTTstats(p);
  285. }
  286.         if (keepSeqnoStats_) {
  287. keepSeqnoStats(p);
  288. }
  289. if (channel_)
  290. printStats();
  291. }
  293. void QueueMonitor::drop(Packet* p)
  294. {
  295. hdr_cmn* hdr = hdr_cmn::access(p);
  296. double now = Scheduler::instance().clock();
  297. int pktsz = hdr->size();
  298. hdr_flags* pf = hdr_flags::access(p);
  300. size_ -= pktsz;
  301. pkts_--;
  302. bdrops_ += pktsz;
  303. pdrops_++;
  305. if (pf->qs())
  306. qs_drops_++;
  308. if (bytesInt_)
  309. bytesInt_->newPoint(now, double(size_));
  310. if (pktsInt_)
  311. pktsInt_->newPoint(now, double(pkts_));
  312. if (channel_)
  313. printStats();
  314. }
  316. // The procedure to estimate the rate of the incoming traffic
  317. void QueueMonitor::estimateRate(Packet *pkt) {
  319. hdr_cmn* hdr  = hdr_cmn::access(pkt);
  320. int pktSize   = hdr->size() << 3; /* length of the packet in bits */
  322. double now = Scheduler::instance().clock();
  323. double timeGap = ( now - prevTime_);
  325. if (timeGap == 0) {
  326. temp_size_ += pktSize;
  327. return;
  328. }
  329. else {
  330. pktSize+= temp_size_;
  331. temp_size_ = 0;
  332. }
  334. prevTime_ = now;
  336. estRate_ = (1 - exp(-timeGap/k_))*((double)pktSize)/timeGap + exp(-timeGap/k_)*estRate_;
  337. }
  339. //The procedure to keep RTT statistics.
  340. void QueueMonitor::keepRTTstats(Packet *pkt) {
  341.         int i, j, topBin, rttInMs, MsPerBin;
  342. hdr_cmn* hdr  = hdr_cmn::access(pkt);
  343. packet_t t = hdr->ptype();
  344. if (t == PT_TCP || t == PT_HTTP || t == PT_FTP || t == PT_TELNET) {
  345. hdr_tcp *tcph = hdr_tcp::access(pkt);
  346. rttInMs = tcph->last_rtt(); 
  347. if (rttInMs < 0) rttInMs = 0;
  348. topBin = maxRTT_ * binsPerSec_;
  349. if (numRTTs_ == 0) {
  350. RTTbins_ = (int *)malloc(sizeof(int)*topBin);
  351. for (i = 0; i < topBin; i++) {
  352. RTTbins_[i] = 0;
  353. }
  354. }
  355. MsPerBin = int(1000/binsPerSec_);
  356. j = (int)(rttInMs/MsPerBin);
  357. if (j < 0) j = 0;
  358. if (j >= topBin) j = topBin - 1;
  359. ++ RTTbins_[j];
  360. ++ numRTTs_;
  361. }
  362. }
  364. //The procedure to keep Seqno (sequence number) statistics.
  365. void QueueMonitor::keepSeqnoStats(Packet *pkt) {
  366.         int i, j, topBin, seqno; 
  367. hdr_cmn* hdr  = hdr_cmn::access(pkt);
  368. packet_t t = hdr->ptype();
  369. if (t == PT_TCP || t == PT_HTTP || t == PT_FTP || t == PT_TELNET) {
  370. hdr_tcp *tcph = hdr_tcp::access(pkt);
  371. seqno = tcph->seqno(); 
  372. if (seqno < 0) seqno = 0;
  373. topBin = int(maxSeqno_ / SeqnoBinSize_);
  374. if (numSeqnos_ == 0) {
  375. SeqnoBins_ = (int *)malloc(sizeof(int)*topBin);
  376. for (i = 0; i < topBin; i++) {
  377. SeqnoBins_[i] = 0;
  378. }
  379. }
  380. j = (int)(seqno/SeqnoBinSize_);
  381. if (j < 0) j = 0;
  382. if (j >= topBin) j = topBin - 1;
  383. ++ SeqnoBins_[j];
  384. ++ numSeqnos_;
  385. }
  386. }
  388. /* ##############
  389.  * Tcl Stuff
  390.  * ##############
  391.  */
  393. static class SnoopQueueInClass : public TclClass {
  394. public:
  395. SnoopQueueInClass() : TclClass("SnoopQueue/In") {}
  396. TclObject* create(int, const char*const*) {
  397. return (new SnoopQueueIn());
  398. }
  399. } snoopq_in_class;
  401. static class SnoopQueueOutClass : public TclClass {
  402. public:
  403. SnoopQueueOutClass() : TclClass("SnoopQueue/Out") {}
  404. TclObject* create(int, const char*const*) {
  405. return (new SnoopQueueOut());
  406. }
  407. } snoopq_out_class;
  409. static class SnoopQueueDropClass : public TclClass {
  410. public:
  411. SnoopQueueDropClass() : TclClass("SnoopQueue/Drop") {}
  412. TclObject* create(int, const char*const*) {
  413. return (new SnoopQueueDrop());
  414. }
  415. } snoopq_drop_class;
  417. static class SnoopQueueEDropClass : public TclClass {
  418. public:
  419. SnoopQueueEDropClass() : TclClass("SnoopQueue/EDrop") {}
  420. TclObject* create(int, const char*const*) {
  421. return (new SnoopQueueEDrop);
  422. }
  423. } snoopq_edrop_class;
  425. /* Added by Yun Wang, for use of In/Out tagger */
  426. static class SnoopQueueTaggerClass : public TclClass {
  427. public:
  428.         SnoopQueueTaggerClass() : TclClass("SnoopQueue/Tagger") {}
  429.         TclObject* create(int, const char*const*) {
  430.                 return (new SnoopQueueTagger);
  431.         }
  432. } snoopq_tagger_class;
  434. static class QueueMonitorEDClass : public TclClass {
  435. public: 
  436. QueueMonitorEDClass() : TclClass("QueueMonitor/ED") {}
  437. TclObject* create(int, const char*const*) { 
  438. return (new EDQueueMonitor);
  439. }
  440. } queue_monitor_ed_class;
  443. /* ############################################################
  444.  * a 'QueueMonitorCompat', which is used by the compat
  445.  * code to produce the link statistics used available in ns-1
  446.  *
  447.  * in ns-1, the counters are the number of departures
  448.  * ############################################################
  449.  */
  451. #include "ip.h"
  452. QueueMonitorCompat::QueueMonitorCompat()
  453. {
  454. memset(pkts_, 0, sizeof(pkts_));
  455. memset(bytes_, 0, sizeof(bytes_));
  456. memset(drops_, 0, sizeof(drops_));
  457. memset(flowstats_, 0, sizeof(flowstats_));
  458. }
  461. /*
  462.  * create an entry in the flowstats_ array.
  463.  */
  465. void
  466. QueueMonitorCompat::flowstats(int flowid)
  467. {
  468. Tcl& tcl = Tcl::instance();
  470. /*
  471.  * here is the deal.  we are in C code.  we'd like to do
  472.  *     flowstats_[flowid] = new Samples;
  473.  * but, we want to create an object that can be
  474.  * referenced via tcl.  (in particular, we want ->name_
  475.  * to be valid.)
  476.  *
  477.  * so, how do we do this?
  478.  *
  479.  * well, the answer is, call tcl to create it.  then,
  480.  * do a lookup on the result from tcl!
  481.  */
  483. tcl.evalf("new Samples");
  484. flowstats_[flowid] = (Samples*)TclObject::lookup(tcl.result());
  485. if (flowstats_[flowid] == 0) {
  486. abort();
  487. /*NOTREACHED*/
  488. }
  489. }
  492. void QueueMonitorCompat::out(Packet* pkt)
  493. {
  494. hdr_cmn* hdr = hdr_cmn::access(pkt);
  495. hdr_ip* iph = hdr_ip::access(pkt);
  496. double now = Scheduler::instance().clock();
  497. int fid = iph->flowid();
  499. if (fid >= MAXFLOW) {
  500. abort();
  501. /*NOTREACHED*/
  502. }
  503. // printf("QueueMonitorCompat::out(), fid=%dn", fid);
  504. bytes_[fid] += hdr_cmn::access(pkt)->size();
  505. pkts_[fid]++;
  506. if (flowstats_[fid] == 0) {
  507. flowstats(fid);
  508. }
  509. flowstats_[fid]->newPoint(now - hdr->timestamp());
  510. QueueMonitor::out(pkt);
  511. }
  513. void QueueMonitorCompat::in(Packet* pkt)
  514. {
  515. hdr_cmn* hdr = hdr_cmn::access(pkt);
  516. double now = Scheduler::instance().clock();
  517. // QueueMonitor::in() *may* do this, but we always need it...
  518. hdr->timestamp() = now;
  519. QueueMonitor::in(pkt);
  520. }
  522. void QueueMonitorCompat::drop(Packet* pkt)
  523. {
  525. hdr_ip* iph = hdr_ip::access(pkt);
  526. int fid = iph->flowid();
  527. if (fid >= MAXFLOW) {
  528. abort();
  529. /*NOTREACHED*/
  530. }
  531. ++drops_[fid];
  532. QueueMonitor::drop(pkt);
  533. }
  535. int QueueMonitorCompat::command(int argc, const char*const* argv)
  536. {
  537. Tcl& tcl = Tcl::instance();
  538. int fid;
  539. if (argc == 3) {
  540. fid = atoi(argv[2]);
  541. if (strcmp(argv[1], "bytes") == 0) {
  542. if (fid >= MAXFLOW) {
  543. abort();
  544. /*NOTREACHED*/
  545. }
  546. tcl.resultf("%d", bytes_[fid]);
  547. return TCL_OK;
  548. } else if (strcmp(argv[1], "pkts") == 0) {
  549. if (fid >= MAXFLOW) {
  550. abort();
  551. /*NOTREACHED*/
  552. }
  553. tcl.resultf("%d", pkts_[fid]);
  554. return TCL_OK;
  555. } else if (strcmp(argv[1], "drops") == 0) {
  556. if (fid >= MAXFLOW) {
  557. abort();
  558. /*NOTREACHED*/
  559. }
  560. tcl.resultf("%d", drops_[fid]);
  561. return TCL_OK;
  562. } else if (strcmp(argv[1], "get-class-delay-samples") == 0) {
  563. if (fid >= MAXFLOW) {
  564. abort();
  565. /*NOTREACHED*/
  566. }
  567. if (flowstats_[fid] == 0) {
  568. /*
  569.  * instantiate one if user actually
  570.  * cares enough to ask for it!
  571.  *
  572.  * (otherwise, need to return "",
  573.  * and then special-case caller to
  574.  * handle this null return.)
  575.  */
  576. flowstats(fid);
  577. }
  578. tcl.resultf("%s", flowstats_[fid]->name());
  579. return TCL_OK;
  580. }
  581. }
  582. return (QueueMonitor::command(argc, argv));
  583. }
  585. static class QueueMonitorCompatClass : public TclClass {
  586.  public: 
  587. QueueMonitorCompatClass() : TclClass("QueueMonitor/Compat") {}
  588. TclObject* create(int, const char*const*) { 
  589. return (new QueueMonitorCompat);
  590. }
  591. } queue_monitor_compat_class;