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

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

通讯编程

开发平台：

Visual C++

jobs.cc：源码内容
  1. /*
  2.  * Copyright (c) 2000-2002, by the Rector and Board of Visitors of the 
  3.  * University of Virginia.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, 
  7.  * with or without modification, are permitted provided 
  8.  * that the following conditions are met:
  9.  *
  10.  * Redistributions of source code must retain the above 
  11.  * copyright notice, this list of conditions and the following 
  12.  * disclaimer. 
  13.  *
  14.  * Redistributions in binary form must reproduce the above 
  15.  * copyright notice, this list of conditions and the following 
  16.  * disclaimer in the documentation and/or other materials provided 
  17.  * with the distribution. 
  18.  *
  19.  * Neither the name of the University of Virginia nor the names 
  20.  * of its contributors may be used to endorse or promote products 
  21.  * derived from this software without specific prior written 
  22.  * permission. 
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  25.  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  26.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  27.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  28.  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE 
  29.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 
  30.  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
  31.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
  32.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
  33.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
  35.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
  36.  * THE POSSIBILITY OF SUCH DAMAGE.
  37.  */
  38. /*
  39.  *                                                                     
  40.  * JoBS - ns-2 prototype implementation                                
  41.  *                                                                     
  42.  * Author: Nicolas Christin <nicolas@cs.virginia.edu>, 2000-2002       
  43.  *       
  44.  * JoBS algorithms originally devised and proposed by       
  45.  * Nicolas Christin and Jorg Liebeherr                                 
  46.  * Grateful acknowledgments to Tarek Abdelzaher for his help and       
  47.  * comments.                                                           
  48.  *                                                                     
  49.  * $Id: jobs.cc,v 1.3 2005/07/27 01:13:44 tomh Exp $                   
  50.  *                
  51.  */
  53. #include "jobs.h"
  55. static class JoBSClass : public TclClass {
  56. public:
  57.   JoBSClass() : TclClass("Queue/JoBS") {}
  58.   TclObject* create(int, const char*const*) {
  59.     return (new JoBS);
  60.   }
  61. } class_jobs;
  63. JoBS::JoBS() : link_(NULL) {
  64. for (int i=1; i<=NO_CLASSES; i++) 
  65. cls_[i] = new PacketQueue;
  67. bind_bool("drop_front_", &drop_front_);
  68. bind_bool("trace_hop_", &trace_hop_);
  69. bind("mean_pkt_size_", &mean_pkt_size_);  // avg pkt size
  70. bind("adc_resolution_type_", &adc_resolution_type_);
  71. bind_bool("shared_buffer_", &shared_buffer_);
  72. total_backlog_Pkts_  = 0;
  73. total_backlog_Bits_  = 0;
  74. pkt_count_ = 0;
  75. idle_ = 1;
  76. ABS_present_ = FALSE;
  77. monitoring_window_ = 0;
  78. last_arrival_ = 0;
  79. last_monitor_update_ = 0;
  80. sliding_arv_pkts_=0;
  81. util_ = 0;
  83. for (int i=1; i<=NO_CLASSES; i++) {
  84. RDC_[i] = (double)i; 
  85. RLC_[i] = (double)i;
  86. ADC_[i] = INFINITY;
  87. ALC_[i] = INFINITY;
  88. sliding_serviced_pkts_[i] = 0;
  89. sliding_serviced_bits_[i] = 0;
  90. sliding_arv_pkts_c[i] = 0;
  91. sliding_class_delay_[i] = 0;
  92. sliding_class_service_rate_[i] = 0;
  93. last_xmit_[i] = 0;
  95. avg_elapsed_[i] = 0.0;
  96. excess_drops_[i] = 0.0;
  97. Rout_last_up_[i] = 0.0;
  98. min_drop_[i] = 0.0;
  99. max_drop_[i] = 1.0;
  100. error_[i] = 0.0;
  101. min_rate_[i] = 0.0;
  102. backlog_Pkts_[i] = 0;
  103. backlog_Bits_[i] = 0;
  104. service_rate_[i] = 0;
  105. current_loss_[i] = 0;
  106. Rout_[i] = 0;
  107. Rin_[i] = 0;
  108. Rout_th_[i] = 0;
  109. last_rate_update_[i] = 0;
  110. }  
  111. }
  113. int JoBS::command(int argc, const char*const* argv) {
  114. Tcl& tcl = Tcl::instance();
  115. double tmp[NO_CLASSES+1];
  117. if (argc >= NO_CLASSES+2) { /* input RDCs/RLCs/ADCs/ALCs */
  118. if (strcmp(argv[1], "init-rdcs") == 0) {
  119. RDC_[0] = -1;
  120. for (int i=1; i<=NO_CLASSES; i++) {
  121. RDC_[i] = atof(argv[i+1]);
  122. if (RDC_[i] == -1)
  123. concerned_RDC_[i] = FALSE;
  124. else
  125.   concerned_RDC_[i] = TRUE;
  126. }
  127. for (int i=1; i<=NO_CLASSES;i++) {
  128. tmp[i] = 1.0;
  129. for (int j = 1; j <= i-1; j++) 
  130.   if (concerned_RDC_[j]) tmp[i] *= RDC_[j];
  131. }
  133. for (int i=1; i<=NO_CLASSES; i++) {
  134. prod_others_[i] = 1.0;
  135. for (int j = 1; j <= NO_CLASSES; j++) 
  136. if ((j != i)&&(concerned_RDC_[j]))
  137.   prod_others_[i] *= tmp[j];
  138. }
  139. if (argc == NO_CLASSES+2) {
  140. fprintf(stdout, "nConfigured RDC, with:n");
  141. for (int i=1; i<=NO_CLASSES; i++) {
  142. fprintf(stdout, "tClass %d: ",i);
  143. if (concerned_RDC_[i]) 
  144. fprintf(stdout, "t%ft(%f)n", (double)RDC_[i], (double) prod_others_[i]);
  145. else 
  146. fprintf(stdout, "tNot concernedn");
  147. }
  148. }
  149. return (TCL_OK);
  150. }
  152. if (strcmp(argv[1], "init-rlcs") == 0) {
  153. RLC_[0] = -1;
  154. for (int i=1; i<=NO_CLASSES; i++) {
  155. RLC_[i] = atof(argv[i+1]);
  156. if (RLC_[i] == -1)
  157. concerned_RLC_[i] = FALSE;
  158. else
  159. concerned_RLC_[i] = TRUE;
  160. }
  162. for (int i=1; i<=NO_CLASSES;i++) {
  163. tmp[i] = 1.0;
  164. for (int j = 1; j <= i-1; j++) 
  165. if (concerned_RLC_[j]) 
  166. tmp[i] *= RLC_[j];
  167. }
  169. for (int i=1; i<=NO_CLASSES; i++) {
  170. loss_prod_others_[i] = 1.0;
  171. for (int j = 1; j <= NO_CLASSES; j++) 
  172. if ((j != i)&&(concerned_RLC_[j]))
  173. loss_prod_others_[i] *= tmp[j];
  174. }
  175. if (argc == NO_CLASSES+2) {
  176. fprintf(stdout, "nConfigured RLC, with:n");
  177. for (int i=1; i<=NO_CLASSES; i++) {
  178. fprintf(stdout, "tClass %d: ",i);
  179. if (concerned_RLC_[i]) 
  180. fprintf(stdout, "t%ft(%f)n", (double)RLC_[i], (double)loss_prod_others_[i]);
  181. else 
  182. fprintf(stdout, "tNot concernedn");
  183. }
  184. }
  186. return (TCL_OK);
  187. }
  188. if (strcmp(argv[1], "init-adcs") == 0) {
  189. ADC_[0] = -1;
  190. for (int i=1; i<=NO_CLASSES; i++) {
  191. ADC_[i] = atof(argv[i+1]);
  192. if (ADC_[i] == -1) {
  193. concerned_ADC_[i] = FALSE;
  194. ADC_[i] = INFINITY;
  195. } else {
  196. concerned_ADC_[i] = TRUE;
  197. ABS_present_ = TRUE;
  198. }
  199. }
  200. if (argc == NO_CLASSES+2) {
  201. fprintf(stdout, "nConfigured ADC, with:n");
  202. for (int i=1; i<=NO_CLASSES; i++) {
  203. fprintf(stdout, "tClass %d: ", i);
  204. if (concerned_ADC_[i]) 
  205. fprintf(stdout, "t%f secsn", (double)ADC_[i]);
  206. else 
  207. fprintf(stdout, "tNot concernedn");
  208. }
  209. }
  211. return (TCL_OK);
  212. }
  213. if (strcmp(argv[1], "init-alcs") == 0) {
  214. ALC_[0] = -1;
  215. for (int i=1; i<=NO_CLASSES; i++) {
  216. ALC_[i] = atof(argv[i+1]);
  217. if (ALC_[i] == -1) {
  218. concerned_ALC_[i] = FALSE;
  219. ALC_[i] = INFINITY;
  220. } else
  221. concerned_ALC_[i] = TRUE;
  222. }
  223. if (argc == NO_CLASSES+2) {
  224. fprintf(stdout, "nConfigured ALC, with:n");
  225. for (int i=1; i<=NO_CLASSES; i++) {
  226. fprintf(stdout, "tClass %d: ",i);
  227. if (concerned_ALC_[i])  
  228. fprintf(stdout, "t%fn", (double)ALC_[i]);
  229. else 
  230. fprintf(stdout, "tNot concernedn");
  231. }
  232. }
  233. return (TCL_OK);
  234. }
  235. if (strcmp(argv[1], "init-arcs") == 0) {
  236. ARC_[0] = -1;
  237. for (int i=1; i<=NO_CLASSES; i++) {
  238. ARC_[i] = atof(argv[i+1]);
  239. if (ARC_[i] == -1) {
  240. concerned_ARC_[i] = FALSE;
  241. ARC_[i] = 0;
  242. } else {
  243. concerned_ARC_[i] = TRUE;
  244. ABS_present_ = TRUE;
  245. }
  246. }
  247. if (argc == NO_CLASSES+2) {
  248. fprintf(stdout, "nConfigured ARC, with:n");
  249. for (int i=1; i<=NO_CLASSES; i++) {
  250. fprintf(stdout, "tClass %d: ",i);
  251. if (concerned_ARC_[i])  
  252. fprintf(stdout, "t%fn", (double)ARC_[i]);
  253. else 
  254. fprintf(stdout, "tNot concernedn");
  255. }
  256. }
  257. return (TCL_OK);
  258. }
  259. } else if (argc == 3) {
  260. if (strcmp(argv[1], "link") == 0) {
  261. LinkDelay* del = (LinkDelay*)TclObject::lookup(argv[2]);
  262. if (del == 0) {
  263. tcl.resultf("JoBS: no LinkDelay object %s",
  264.     argv[2]);
  265. return(TCL_ERROR);
  266. }
  267. link_ = del;
  268. for (int i=1; i <= NO_CLASSES; i++)
  269. service_rate_[i] = 0;
  270. return (TCL_OK);
  271. }
  272. if (strcmp(argv[1], "sampling-period") == 0) {
  273. sampling_period_ = atoi(argv[2]);
  274. if (sampling_period_ < 0) {
  275. fprintf(stderr, "JoBS: sampling period must be positive!!n");
  276. abort();
  277. return (TCL_ERROR); // __NOT REACHED__
  278. } else 
  279. return (TCL_OK);      
  280. }
  281. if (strcmp(argv[1], "id") == 0) {
  282. link_id_ = (int)atof(argv[2]);
  283. return (TCL_OK);
  284. }
  285. if (strcmp(argv[1], "trace-file") == 0) {
  286. file_name_ = new(char[500]);
  287. strcpy(file_name_, argv[2]);
  288. if (strcmp(file_name_, "null")) {
  289. trace_hop_ = true;
  290. } else {
  291. trace_hop_ = false;
  292. }
  293. return (TCL_OK);
  294. }
  295. } else if (argc == 2) {
  296. if (strcmp(argv[1], "initialize") == 0) {
  297. double myMaxPi=0;
  298. for (int i = 1; i <= NO_CLASSES; i++) 
  299. if (prod_others_[i] > myMaxPi) 
  300. myMaxPi = prod_others_[i];
  302. Kp_static_ = -2/(double)(myMaxPi*mean_pkt_size_*sampling_period_);
  304.       // Open files
  305. if (trace_hop_) {
  306. if ((hop_trace_ = fopen(file_name_, "w"))==NULL) {
  307. fprintf(stderr, "Problem with opening the per-hop trace file: %sn", file_name_);
  308. abort();   
  309. }
  310. }    
  311. return (TCL_OK);
  312. }
  313. if (strcmp(argv[1], "copyright-info") == 0) {
  314. fprintf(stdout, "n----------------------------------------------------------nn");
  315. fprintf(stdout, "JoBS scheduler/dropper [prototype ns-2 implementation]n");
  316. fprintf(stdout, "Version 1.0 (CVS Revision: $Id: jobs.cc,v 1.3 2005/07/27 01:13:44 tomh Exp $)nn");
  317. fprintf(stdout, "ns-2 implementation by Nicolas Christin <nicolas@cs.virginia.edu>n");
  318. fprintf(stdout, "JoBS algorithms proposed by Nicolas Christin and Jorg Liebeherr.n");
  319. fprintf(stdout, "Grateful acknowledgments to Tarek Abdelzaher for his help and comments.n");
  320. fprintf(stdout, "Visit http://qosbox.cs.virginia.edu for moren");
  321. fprintf(stdout, "information.nn");
  322. fprintf(stdout, "Copyright (c) 2000-2002 by the Rector and Board of Visitors of then");
  323. fprintf(stdout, "University of Virginia.n");
  324. fprintf(stdout, "All Rights Reserved.n");
  325. fprintf(stdout, "----------------------------------------------------------nn");
  326. return (TCL_OK);
  327. }
  328. }
  329. return (Queue::command(argc, argv));
  330. }
  332. // *******************************************************************
  333. // JoBS: Simplified Packetization of the Fluid Flow Model.
  334. // *******************************************************************
  336. Packet* JoBS::deque() { // Lower classes are better. 
  337. double  cur_time  = Scheduler::instance().clock(); 
  338. double error;
  339. double maxError;
  340. int svc_class = 0;
  341.   
  342. error = 0;
  344. // Fast translation of service rates into packet forwarding decisions
  346. maxError = -INFINITY;
  347. for (int i=1; i<=NO_CLASSES; i++) {
  348. if (cls_[i]->head()) {
  349. error = (double)Rout_th_[i] - Rout_[i];
  350. if (error > maxError) {
  351. maxError = error;
  352. svc_class = i;
  353. }
  354. }
  355. }
  357. if (svc_class == 0) {
  358. idle_ = 1;
  359. if (&Scheduler::instance() != NULL)
  360. idletime_ = cur_time;
  361. else
  362. idletime_ = 0.0;
  363. return NULL; /* Idle system */
  364. } else {
  365. idle_ = 0;
  366. Packet* p = cls_[svc_class]->deque();
  367. hdr_cmn* cm_h = hdr_cmn::access(p);
  368.     
  369. total_backlog_Pkts_--;
  370. total_backlog_Bits_ -= 8*cm_h->size();
  371. backlog_Pkts_[svc_class]--;
  372. backlog_Bits_[svc_class] -= 8*cm_h->size();
  373. Rout_[svc_class] += 8*cm_h->size();
  374. Rout_last_up_[svc_class] = cur_time;
  376. sliding_serviced_pkts_[svc_class] ++;
  377. sliding_serviced_bits_[svc_class] += 8*cm_h->size();
  378. sliding_class_delay_[svc_class] 
  379.   = ((sliding_serviced_pkts_[svc_class]-1)*(sliding_class_delay_[svc_class])
  380.      +(cur_time-cm_h->ts_))/(sliding_serviced_pkts_[svc_class]);
  381. last_xmit_[svc_class] = cur_time+(8.*cm_h->size()/(double)link_->bandwidth());
  382. return(p);
  383. }
  384. }
  386. // *******************************************************************
  387. // JoBS: Enqueue packet 
  388. // *******************************************************************
  390. void JoBS::enque(Packet* pkt) {
  391. double* DeltaR;
  392. int i;
  393. hdr_ip*  ip_h = hdr_ip::access(pkt);
  394. hdr_cmn* cm_h = hdr_cmn::access(pkt);
  396. int prio = ip_h->prio_;
  397. if ((prio < 1) || (prio > NO_CLASSES)) {
  398. printf("Bad priority valuen");
  399. abort();
  400. }
  401.   
  402. double cur_time = Scheduler::instance().clock(); 
  403. cm_h->ts_ = cur_time; // timestamp the packet
  404. cls_[prio]->enque(pkt);
  406. monitoring_window_ -= cur_time-last_monitor_update_;
  407. last_monitor_update_ = cur_time;
  408. if (monitoring_window_ <= 0) {
  409. updateStats(pkt, RESET_STATS);
  410. monitoring_window_ = MON_WINDOW_SIZE;
  411. } else {
  412. updateStats(pkt, UPDATE_STATS);
  413. }
  415. // Reset arrival, input, and service curves if the scheduler is 
  416. // not busy
  418. if (idle_) {
  419. for (i=1; i<= NO_CLASSES; i++) {
  420.   Arrival_[i]=0.0;
  421.   Rin_[i]=0.0;
  422.   Rout_[i]=0.0;
  423.   Rout_th_[i]=0.0;
  424.   last_rate_update_[i] = 0;
  425.   Rout_last_up_[i] = cur_time;
  426.   idle_ = 0;
  427. }
  428. }
  430. arvAccounting(pkt);
  432. /* Is the buffer full? */  
  433. if (!shared_buffer_ && backlog_Pkts_[prio] > qlim_/NO_CLASSES) {
  434. /* separate buffers: no guarantees on packet drops 
  435.  * can be offered
  436.  * thus we drop the incoming packet
  437.  */
  438. if (drop_front_)
  439. dropFront(prio, WITH_UPDATE);
  440. else
  441. dropTail(prio, WITH_UPDATE);    
  442. } else {
  443.   /* shared buffer */
  444. if (total_backlog_Pkts_ > qlim_) {
  445. if (!concerned_RLC_[prio]) {
  446. if (!concerned_ALC_[prio]) {
  447. // No ALC, no RLC on that class. Drop the incoming packet.
  448. if (drop_front_)
  449. dropFront(prio, WITH_UPDATE);
  450. else
  451. dropTail(prio, WITH_UPDATE);
  452. } else {
  453. // No RLC on that class. Drop the incoming packet if you can...
  454. if (current_loss_[prio]+(double)8*cm_h -> size()/(double)Arrival_[prio] <= ALC_[prio]) {
  455. if (drop_front_)
  456. dropFront(prio, WITH_UPDATE);
  457. else     
  458. dropTail(prio, WITH_UPDATE);
  459. } else {
  460. // If it doesn't work, pick another class
  461. if (drop_front_)
  462. dropFront(pickDroppedRLC(RESOLVE_OVERFLOW), WITH_UPDATE);
  463. else     
  464. dropTail(pickDroppedRLC(RESOLVE_OVERFLOW), WITH_UPDATE);
  465. }
  466. }
  467. } else {
  468. // RLC on that class (w/ or w/o ALC), pick a class according to the RLC
  469.   if (drop_front_)
  470. dropFront(pickDroppedRLC(RESOLVE_OVERFLOW), WITH_UPDATE);
  471.   else     
  472. dropTail(pickDroppedRLC(RESOLVE_OVERFLOW), WITH_UPDATE);
  473. }
  474. }
  475. }
  476. pkt_count_ ++;
  477. enforceWC(); // Change rates if some classes have entered/left the system
  478. // since the last update
  480. if ((ABS_present_)&&(!minRatesNeeded(ip_h -> prio()))) {
  481. DeltaR = assignRateDropsADC();   
  483. if (DeltaR != NULL) {
  484. for (i = 1; i <= NO_CLASSES; i++) 
  485. service_rate_[i] += DeltaR[i];
  486. delete []DeltaR; 
  487. }
  489. DeltaR = adjustRatesRDC();
  491. if (DeltaR) {
  492. for (i = 1; i <= NO_CLASSES; i++) 
  493. service_rate_[i] += DeltaR[i];
  494. delete []DeltaR;   
  495. }
  497. pkt_count_ = 0;
  499. } else if (pkt_count_ >= sampling_period_) {
  500. /* Is it time for a new evaluation of the system? */
  501. DeltaR = adjustRatesRDC();
  502. if (DeltaR != NULL) {
  503. for (i = 1; i <= NO_CLASSES; i++)
  504. service_rate_[i] += DeltaR[i];
  505. delete []DeltaR;
  506. } 
  507. pkt_count_ = 0;
  508. }
  509. return;
  510. }
  512. // *******************************************************************
  513. // Auxiliary functions (helpers) follow
  514. // *******************************************************************
  516. // 1) Scheduling Primitives
  518. // *******************************************************************
  519. // JoBS: Enforce Work-Conserving Property
  520. // *******************************************************************
  522. int JoBS::enforceWC() {
  523. int i;
  524. int activeClasses;
  525. int updated;
  527. updated = FALSE;
  528. activeClasses = 0;
  530. for (i = 1; i <= NO_CLASSES; i++) {
  531. if (cls_[i]->head()) 
  532. activeClasses++;
  533. if ((cls_[i] -> head() && service_rate_[i] <= PRECISION_ERROR)
  534.     ||(cls_[i] -> head() == NULL && service_rate_[i] > 0)) 
  535.   updated = TRUE;
  536. }
  538. if (updated) {
  539. for (i = 1; i <= NO_CLASSES; i++) {
  540. if (cls_[i]->head() == NULL) {
  541. service_rate_[i] = 0;
  542. } else {
  543. if (activeClasses > 0)
  544. service_rate_[i] = link_->bandwidth()/(double)activeClasses;
  545. else 
  546. service_rate_[i] = 0 ;
  547. }
  548. }
  549. }
  551. return (updated);
  552. }
  554. // *******************************************************************
  555. // JoBS: Adjusts the rates for meeting the RDCs
  556. // *******************************************************************
  558. double* JoBS::adjustRatesRDC() {
  559. int i, j;
  560. int RDC_Classes, activeClasses;
  561. double* result;
  562. double credit, available, lower_bound, upper_bound;
  563. double bk;
  564. double cur_time;
  566. cur_time = Scheduler::instance().clock(); 
  567.   
  568. activeClasses = 0;
  569. RDC_Classes = 0;
  571. upper_bound = link_ -> bandwidth();
  573. for (i = 1; i <= NO_CLASSES; i++)
  574. if (cls_[i]->head() != NULL) {
  575. activeClasses++;
  576. if (concerned_RDC_[i]) 
  577. RDC_Classes++;
  578. else 
  579. upper_bound -= service_rate_[i];
  580. }
  582. result = new double[NO_CLASSES+1];
  584. if (result == NULL) 
  585. return NULL;
  587. for (i = 0; i <= NO_CLASSES; i++) 
  588. result[i] = 0;
  590. if (upper_bound < PRECISION_ERROR || activeClasses == 0) return result;
  592. credit = 0;
  593. lower_bound = 0;
  595. updateError();
  596. min_share_ = 1.0;
  597. bk = 0;
  599. for (i = 1; i <= NO_CLASSES; i++) 
  600. if (concerned_RDC_[i])
  601. bk += Rin_[i];
  603. for (i = 1; i <= NO_CLASSES; i++) 
  604. if ((double)Rin_[i]/(double)bk < min_share_)
  605. min_share_ = (double)Rin_[i]/(double)bk;
  606.   
  607. /*
  608.  * note that the formula for Kp is slightly different 
  609.  * from the formula derived in CS-2001-21. 
  610.  * the formula used here provides better results 
  611.  * at the expense of more complicated computations.
  612.  */
  614. Kp_dynamic_ = Kp_static_*pow(upper_bound, 2.)*min_share_*util_*max(util_, 1.0);
  616. credit = 0;
  617. for (i = 1; i <= NO_CLASSES; i++) {
  618. if ((cls_[i]->head() != NULL)&&(concerned_RDC_[i])) {
  619. result[i] = Kp_dynamic_*(error_[i]); 
  620. }
  621. }
  623. // saturation 
  625. for (i = 1; i <= NO_CLASSES; i++) 
  626. if (cls_[i]->head() != NULL) {
  627. if (concerned_RDC_[i]) {
  628. lower_bound += max(0, min_rate_[i]);
  629. } 
  630. }
  632. for (i = 1; i <= NO_CLASSES; i++) {
  633. if ((concerned_RDC_[i])&&(result[i] + service_rate_[i] > upper_bound)) {
  634. for (j = 0; j <= NO_CLASSES; j++) {
  635. if (concerned_RDC_[j]) {
  636. if (j == i) 
  637. result[j] = (upper_bound-service_rate_[j])  
  638.     + min_rate_[j] - lower_bound;
  639. else
  640. result[j] = -service_rate_[j]+min_rate_[j];
  641. }
  642. }
  643. return result;
  644. }
  645. if (concerned_RDC_[i] && result[i] + service_rate_[i] < min_rate_[i]) {
  646. credit += service_rate_[i]+result[i]-min_rate_[i]; 
  647. // "credit" is in fact a negative number
  648. result[i] = -service_rate_[i]+min_rate_[i];
  649. }
  650. }
  652. for (i = NO_CLASSES; (i > 0)&&(credit < 0); i--) {
  653. if ((cls_[i]->head() != NULL)&&(concerned_RDC_[i])) {
  654. available = result[i] + service_rate_[i]-min_rate_[i];
  655. if (available >= -credit) {
  656. result[i] += credit;
  657. credit = 0;
  658. } else {
  659. result[i] -= available;
  660. credit += available;
  661. }      
  662. }
  663. }
  664. return result;
  665. }
  667. // *******************************************************************
  668. // JoBS: Assigns the rates (and possibly drops some traffic) 
  669. // needed for meeting the ADCs
  670. // *******************************************************************
  672. double* JoBS::assignRateDropsADC() {
  673. double* x;
  674. //double myRatios[NO_CLASSES+1];
  675. double c[NO_CLASSES+1], n[NO_CLASSES+1];
  676. double k[NO_CLASSES+1], target[NO_CLASSES+1];
  677. double available[NO_CLASSES+1];
  678. double toDrop;
  679. int lowest, highest;
  680. int victim_class, keep_going;
  681. int i;
  682. Packet* p; 
  683. hdr_cmn* cm_h; 
  684. double cur_time = Scheduler::instance().clock(); 
  686. x = new double[NO_CLASSES+1];
  688. if (x == NULL) return NULL;
  690. for (i = 0;i <= NO_CLASSES; i++) 
  691. x[i] = 0;
  693. keep_going = TRUE;
  695. for (i = 1; i <= NO_CLASSES; i++) {
  696. if (cls_[i]->head() != NULL) {
  697. p = cls_[i]->head();
  698. cm_h = hdr_cmn::access(p);
  699. n[i] = (double)service_rate_[i];
  700. k[i] = (double)backlog_Bits_[i];
  701. available[i] = service_rate_[i];
  703. if (concerned_ADC_[i]) { 
  704. c[i] = (double)max((double)ADC_[i]-(cur_time-cm_h->ts_),1e-10);
  705. target[i] = (double)k[i]/(double)c[i];
  706. available[i] = -(target[i] - n[i]); 
  707. } 
  708. if (concerned_ARC_[i]) { 
  709. if (n[i] - ARC_[i] < available[i])
  710. available[i] = n[i] - ARC_[i];
  711. }
  712. } else {
  713. available[i] = service_rate_[i];
  714. n[i] = 0;
  715. k[i] = 0;
  716. c[i] = 0;
  717. }
  718. }
  720. // Step 1: Adjust rates 
  722. highest = 1;
  723. lowest  = NO_CLASSES;
  725. while ((highest < NO_CLASSES+1)&&(available[highest] >= 0))
  726. highest++; // which is the highest class that needs more service? 
  727. while ((lowest > 0)&&(available[lowest] <= 0))
  728. lowest--;  // which is the lowest class that needs less service? 
  731. while ((highest != NO_CLASSES+1)&&(lowest != 0)) {
  732. // give the excess service from lowest to highest 
  733. if (available[lowest]+available[highest] > 0) {
  734. // Still some "credit" left 
  735. // Give all that is needed by "highest" 
  736. n[lowest]  -= -available[highest];
  737. n[highest] += -available[highest];
  739. available[lowest]  -= -available[highest];
  740. available[highest] = 0;
  742. while ((highest < NO_CLASSES+1)&&(available[highest] >= 0))
  743. highest++;  // which is the highest class that needs more service? 
  745. } else if (available[lowest]+available[highest] == 0) {
  746. // No more credit left but it's fine 
  747. n[lowest]  -= -available[highest];
  748. n[highest] += -available[highest];
  750. available[highest] = 0;
  751. available[lowest]  = 0;
  753. while ((highest < NO_CLASSES+1)&&(available[highest] >= 0))
  754. highest++;  // which is the highest class that needs more service? 
  755. while ((lowest > 0)&&(available[lowest] <= 0))
  756. lowest--;   // which is the lowest class that needs less service? 
  758. } else if (available[lowest]+available[highest] < 0) {
  759. // No more credit left and we need to switch to another class 
  760. n[lowest]  -= available[lowest];
  761. n[highest] += available[lowest];
  763. available[highest] += available[lowest];
  764. available[lowest]  = 0;
  766. while ((lowest > 0)&&(available[lowest] <= 0))
  767. lowest--;  // which is the lowest class that needs less service? 
  768. }
  769. }
  771. for (i = 1; i <= NO_CLASSES; i++) {
  772. if (cls_[i]->head() != NULL)
  773. x[i] = n[i] - (double)service_rate_[i];
  774. else 
  775. x[i] = - (double)service_rate_[i] ;
  776. }
  778. // Step 2: Adjust drops 
  780. if (highest != NO_CLASSES+1) {
  781. // Some class still needs additional service 
  782. if (adc_resolution_type_ == SHARED_PAIN) {
  783. // Drop from all classes
  784. toDrop = 0;
  785. for (i = 1; i <= NO_CLASSES; i++) 
  786. if (available[i] < 0 && concerned_ADC_[i] && cls_[i]->head()) 
  787. toDrop += k[i] - c[i]*n[i];
  789. while ((toDrop > 0)&&(keep_going)) {
  790. victim_class = pickDroppedRLC(RESOLVE_ADC);
  791. if (drop_front_) 
  792. p = cls_[victim_class] -> head();
  793. else
  794. p = cls_[victim_class] -> tail();
  795.       
  796. cm_h = hdr_cmn::access(p);
  798. if (current_loss_[victim_class]+(double)8*cm_h -> size()/(double)Arrival_[victim_class] > ALC_[victim_class]) {
  799. keep_going = FALSE;
  800. } else {
  801. toDrop -= (double)8*cm_h -> size();
  803. if (drop_front_) 
  804. dropFront(victim_class, WITH_UPDATE);
  805. else
  806. dropTail(victim_class, WITH_UPDATE);
  807. }
  808. }
  809. } else {
  810. // Drop solely from the class(es) that need(s) more service
  811. for (i = 1; i <= NO_CLASSES; i++) {
  812. if (available[i] < 0 && cls_[i] -> head()) {
  813. k[i] = c[i]*n[i];
  815. while ((backlog_Bits_[i] > k[i])&&(keep_going)) {
  816. if (drop_front_) {
  817. p = cls_[i] -> head();
  818. cm_h = hdr_cmn::access(p);
  819. if (current_loss_[i]+(double)8*cm_h -> size()/(double)Arrival_[i] > ALC_[i]) {
  820. keep_going = FALSE;
  821. } else 
  822. dropFront(i, WITH_UPDATE);
  823. } else {
  824. p = cls_[i] -> tail();
  825. cm_h = hdr_cmn::access(p);
  826. if (current_loss_[i]+(double)8*cm_h -> size()/(double)Arrival_[i] > ALC_[i]) {
  827. keep_going = FALSE;
  828. } else 
  829. dropTail(i, WITH_UPDATE);
  830. }
  831. }
  832. k[i] = backlog_Bits_[i];
  833. }
  834. }      
  835. }
  836. } 
  838. for (i = 1; i <= NO_CLASSES; i++) 
  839. if (cls_[i]->head() && concerned_ADC_[i]) {
  840. if (c[i] > 0) {
  841. if (concerned_ADC_[i] && !concerned_ARC_[i]) {
  842. min_rate_[i] = (double)k[i]/(double)c[i];
  843. } else 
  844. min_rate_[i] = (double)n[i];
  845. } else {
  846. min_rate_[i] = INFINITY;
  847. }
  848. } else  if (cls_[i]->head() && concerned_ARC_[i]) {
  849. min_rate_[i] = n[i];
  850. } else {
  851.   min_rate_[i] = 0.0;    
  852. }
  853. return (x);
  854. }
  856. // 1bis) Scheduling Helpers
  858. // *******************************************************************
  859. // JoBS: Update Error - used by the RDC feedback loop controller
  860. // *******************************************************************
  862. void JoBS::updateError() {
  863. int i;
  864. int activeClasses, backloggedClasses;
  865. double meanWeightedDelay;
  867. meanWeightedDelay = 0;
  868. activeClasses = 0 ; 
  869. backloggedClasses = 0;
  871. for (i = 1; i <= NO_CLASSES; i++) 
  872. if (cls_[i]->head() != NULL) {
  873. backloggedClasses++;
  874. if (concerned_RDC_[i]) {
  875. meanWeightedDelay += prod_others_[i]*projDelay(i);
  876. activeClasses ++;
  877. }    
  878. }
  880. if (activeClasses > 0) 
  881. meanWeightedDelay /= (double)activeClasses;
  882. else if (backloggedClasses == 0) {
  883. fprintf(stderr, "JoBS::updateError() called but there's no backlog!n");
  884. abort();
  885. }
  887. for (i = 1; i <= NO_CLASSES; i++) 
  888. if ((cls_[i]->head() != NULL)&&(concerned_RDC_[i])) {
  889. error_[i] = meanWeightedDelay-prod_others_[i]*projDelay(i);
  890. } else {
  891. error_[i] = 0.0; // either the class isn't concerned, or it's not backlogged
  892. // in any case, the rate shouldn't be adjusted.
  893. }
  894. return;
  895. }
  896. // *******************************************************************
  897. // JoBS: Derives the rates needed for meeting the ADC.
  898. // Returns true if the sum of the rates needed for meeting the ADC
  899. // is less than the link's bandwidth, false otherwise.
  900. // It's also the place where the "RED" algorithm is triggered.
  901. // Side effect (desired): assigns a value to min_rate_[i]
  902. // *******************************************************************
  904. int JoBS::minRatesNeeded(int priority) {
  905. int result;
  906. int i;
  907. double cur_time;
  908. Packet* p;
  909. hdr_cmn* cm_h; 
  911. cur_time = Scheduler::instance().clock();
  912. result = TRUE;
  913.   
  914. for (i = 1; i <= NO_CLASSES; i++) {
  915. if (cls_[i]->head() != 0 && (concerned_ADC_[i] || concerned_ARC_[i])) {
  916. p = cls_[i]->head();
  917. cm_h = hdr_cmn::access(p);
  919. if (concerned_ADC_[i]) { 
  920. if ((ADC_[i] - (cur_time-cm_h->ts_)) > 0 ) {
  921. // min rate needed for ADC
  922. min_rate_[i] = (double)(backlog_Bits_[i])
  923.     /(double)(ADC_[i] - (cur_time-cm_h->ts_));
  924. if (concerned_ARC_[i] && ARC_[i] > min_rate_[i]) {
  925. // min rate needed for ADC+ARC
  926. min_rate_[i] = ARC_[i];
  927. }
  928. } else 
  929. min_rate_[i] = INFINITY; 
  930. } else if (concerned_ARC_[i]) {
  931. // no ADC, an ARC
  932. min_rate_[i] = ARC_[i];
  933. }
  934. if (min_rate_[i] > service_rate_[i]) 
  935. result = FALSE;
  936. } else 
  937. min_rate_[i] = 0.0;
  938. }
  939. return result;
  940. }
  942. // *******************************************************************
  943. // JoBS: Returns the value of the delay metric for class i
  944. // *******************************************************************
  946. double JoBS::projDelay(int i) {
  947. double cur_time  = Scheduler::instance().clock(); 
  948. if (cls_[i]->head() != NULL) {
  949. Packet* p = cls_[i]->head();
  950. hdr_cmn* cm_h = hdr_cmn::access(p);
  951. return (cur_time - cm_h -> ts_);
  952. } else return 0.0; // __NOT REACHED__
  953. }
  955. // 2) Dropping Primitives
  957. // *******************************************************************
  958. // JoBS: Choose which class to drop from in case of a buffer overflow
  959. // *******************************************************************
  961. int JoBS::pickDroppedRLC(int mode) {
  962. double Mean;
  963. double loss_error[NO_CLASSES+1];
  964. int i, activeClasses, backloggedClasses;
  965. int class_dropped;
  966. double maxError;
  967. double maxALC;
  968. double cur_time  = Scheduler::instance().clock(); 
  970. hdr_cmn* cm_h; 
  972. class_dropped = -1;
  973. maxError = 0;
  974. Mean = 0;
  975. activeClasses = 0;
  976. backloggedClasses = 0;
  978. for (i = 1; i <= NO_CLASSES; i++) 
  979. if (cls_[i]->head() != NULL) {
  980. backloggedClasses ++;
  981. if (concerned_RLC_[i]) {
  982. Mean += loss_prod_others_[i]*current_loss_[i];
  983. activeClasses ++;
  984. }    
  985. }
  987. if (activeClasses > 0) 
  988. Mean /= (double)activeClasses;
  989. else if (backloggedClasses == 0) {
  990. fprintf(stderr, "JoBS::pickDroppedRLC() called but there's no backlog!n");
  991. abort();
  992. }
  994. if (activeClasses == 0) 
  995. class_dropped = NO_CLASSES+1; // no classes are concerned by RLCs (NO_CLASSES+1 means "ignore RLC")
  996. else {
  997. for (i = 1; i <= NO_CLASSES; i++) 
  998. if ((cls_[i]->head() != NULL)&&(concerned_RLC_[i])) 
  999. loss_error[i]=loss_prod_others_[i]*current_loss_[i]-Mean;
  1000. else 
  1001. loss_error[i] = INFINITY; 
  1002.     
  1003. for (i = 1; i <= NO_CLASSES; i++)
  1004. if ((cls_[i]->head() != NULL)&&(loss_error[i] <= maxError)) {
  1005. maxError = loss_error[i]; // Find out which class is the most below the mean
  1006. class_dropped = i;   // It's the one that needs to be dropped
  1007. // Ties are broken in favor of the higher priority classes (i.e., if
  1008. // two classes present the same deviation, the lower priority class 
  1009. // will get dropped).
  1010. } 
  1012. if (class_dropped != -1) {
  1013. if (drop_front_)
  1014. cm_h = hdr_cmn::access(cls_[class_dropped] -> head());
  1015. else
  1016. cm_h = hdr_cmn::access(cls_[class_dropped] -> tail());
  1018. if (current_loss_[class_dropped]+(double)8*cm_h -> size()/(double)Arrival_[class_dropped] > ALC_[class_dropped])
  1019. class_dropped = NO_CLASSES+1; // the class to drop for meeting the RLC will defeat the ALC: ignore RLC.
  1020. } else 
  1021. class_dropped = NO_CLASSES+1;
  1022. }
  1024. if (class_dropped != -1) { // this test is here only for "safety purposes" 
  1025. // it should always return true at this point.
  1026. if (class_dropped == NO_CLASSES+1) {
  1027. maxALC = -INFINITY;
  1028. for (i = 1; i <= NO_CLASSES; i++) {
  1029. if (cls_[i] -> tail() != NULL) {
  1030. if (ALC_[i]-current_loss_[i] > maxALC);
  1031. maxALC = ALC_[i]-current_loss_[i]; // pick the class which is the furthest from its ALC
  1032. class_dropped = i;
  1033. }
  1034. }
  1035. if (drop_front_)
  1036.   cm_h = hdr_cmn::access(cls_[class_dropped]->head());
  1037. else
  1038.   cm_h = hdr_cmn::access(cls_[class_dropped]->tail());
  1039. if ((mode == RESOLVE_OVERFLOW)
  1040.     &&(current_loss_[class_dropped]+(double)8*cm_h -> size()/(double)Arrival_[class_dropped] > ALC_[class_dropped])) {
  1042. fprintf(stderr, "*** Warning at time t=%f: ALC violated in class %d on link %dn(reason: buffer overflow impossible to resolve otherwise)nPkt size=%d bitstold_loss[%d]=%ftnew_loss[%d]=%ftArrival_[%d]=%ftALC[%d]=%fn",
  1043. cur_time, link_id_,
  1044. class_dropped, 8*cm_h -> size(),
  1045. class_dropped, current_loss_[class_dropped],
  1046. class_dropped, current_loss_[class_dropped]+(double)8*cm_h -> size()/(double)Arrival_[class_dropped],
  1047. class_dropped, (double)Arrival_[class_dropped],
  1048. class_dropped, ALC_[class_dropped]);
  1049. }
  1050. }
  1051. } else {
  1052. fprintf(stderr, "Trying to drop a packet, but there's nothing in any queue!n");
  1053. abort();
  1054. }
  1055. return class_dropped;
  1056. }
  1058. // *******************************************************************
  1059. // JoBS: Drops traffic from the tail of the specified class, and 
  1060. // update the statistics.
  1061. // *******************************************************************
  1063. void JoBS::dropTail(int prio, int strategy) {
  1064. Packet *p;
  1065. hdr_cmn *cm_h;
  1067. p = cls_[prio] -> tail();
  1068. cm_h = hdr_cmn::access(p);
  1070. total_backlog_Pkts_ --;
  1071. total_backlog_Bits_ -= 8*cm_h->size();
  1072. backlog_Pkts_[prio] --;
  1073. backlog_Bits_[prio] -= 8*cm_h->size();
  1074. Rin_[prio] -= 8*cm_h->size();
  1075. if (strategy == WITH_UPDATE) {
  1076. for (int i = 1; i <= NO_CLASSES; i++) 
  1077. current_loss_[i] = min_drop_[i];
  1078. current_loss_[prio] += (double)8*cm_h -> size()
  1079.     /(double)Arrival_[prio];
  1080. }
  1081. cls_[prio] -> remove(p);
  1082. drop(p);
  1083. return;
  1084. }
  1086. // *******************************************************************
  1087. // JoBS: Drops traffic from the head of the specified class, and 
  1088. // update the statistics.
  1089. // *******************************************************************
  1091. void JoBS::dropFront(int prio, int strategy) {
  1092. Packet *p;
  1093. hdr_cmn *cm_h;
  1095. p = cls_[prio] -> head();
  1096. cm_h = hdr_cmn::access(p);
  1097. total_backlog_Pkts_ --;
  1098. total_backlog_Bits_ -= 8*cm_h->size();
  1099. backlog_Pkts_[prio] --;
  1100. backlog_Bits_[prio] -= 8*cm_h->size();
  1101. Rin_[prio] -= 8*cm_h->size();
  1102. if (strategy == WITH_UPDATE) {
  1103. for (int i = 1; i <= NO_CLASSES; i++) 
  1104. current_loss_[i] = min_drop_[i];
  1105. current_loss_[prio] += (double)8*cm_h -> size()
  1106.   /(double)Arrival_[prio];
  1107. }
  1108. cls_[prio] -> remove(p);
  1109. drop(p);
  1110. return;
  1111. }  
  1114. // 3) Other Helpers
  1116. // *******************************************************************
  1117. // JoBS: Update internal variables upon a packet arrival.
  1118. // *******************************************************************
  1120. void JoBS::arvAccounting(Packet* thePacket) {
  1121. int i;
  1122. double cur_time;
  1123. hdr_cmn* cm_h;
  1124. hdr_cmn* cm_h1;
  1125. hdr_cmn* cm_h2; 
  1126. hdr_ip*  ip_h; 
  1128. cur_time = Scheduler::instance().clock();
  1129. cm_h = hdr_cmn::access(thePacket);
  1130. ip_h = hdr_ip::access(thePacket);
  1132. /* Update curves */
  1134. Arrival_[ip_h -> prio()]      += 8*cm_h -> size();
  1135. Rin_    [ip_h -> prio()]      += 8*cm_h -> size();
  1136. if (last_rate_update_[ip_h -> prio()] == 0) {
  1137. last_rate_update_[ip_h -> prio()] = cur_time;
  1138. } else {
  1139. Rout_th_ [ip_h -> prio()]      += (cur_time-last_rate_update_[ip_h -> prio()])*service_rate_[ip_h -> prio()];
  1140. last_rate_update_[ip_h -> prio()] = cur_time;
  1141. }
  1142. backlog_Pkts_[ip_h -> prio()] ++;
  1143. backlog_Bits_[ip_h -> prio()] += 8*cm_h -> size();
  1144. total_backlog_Bits_ += 8*cm_h -> size();
  1145. total_backlog_Pkts_ ++;
  1147. for (i = 1; i <= NO_CLASSES; i++) {
  1148. if (Arrival_[i] > 0) {
  1149. current_loss_[i] = (double)(Arrival_[i] - Rin_[i])/(double)(Arrival_[i]);
  1150. min_drop_[i] = (double)(max(0.0, (1.0-(double)(Rin_[i])/(double)Arrival_[i])));
  1151. max_drop_[i] = (double)(min(1.0, (1.0-(double)((double)Rout_[i]/(double)Arrival_[i]))));
  1152. } else {
  1153. current_loss_[i] = 0;
  1154. min_drop_[i] = 0.0;
  1155. max_drop_[i] = 0.0;
  1156. }
  1158. if (cls_[i]->head() != NULL) {
  1159. cm_h1 = hdr_cmn::access(cls_[i]->head());
  1160. cm_h2 = hdr_cmn::access(cls_[i]->tail());
  1161. avg_elapsed_[i] = (2*cur_time - cm_h1 -> ts_ - cm_h2 -> ts_)/((backlog_Pkts_[i]>1)? 2.0 :1.0);
  1162. }
  1163. }
  1164. return;
  1165. }
  1167. // 4) Debugging Tools
  1169. void JoBS::updateStats(Packet* p, int action) {
  1170. double cur_time = Scheduler::instance().clock();
  1171. hdr_cmn* cm_h;
  1172. hdr_ip* ip_h;
  1174. cm_h = hdr_cmn::access(p);
  1175. ip_h = hdr_ip::access(p);
  1176. if (action == UPDATE_STATS) {
  1177. sliding_arv_pkts_++;
  1178. sliding_arv_pkts_c[ip_h->prio()]++;
  1179. sliding_inter_ = (cur_time - last_arrival_ + sliding_inter_ * (sliding_arv_pkts_-1))
  1180.     /(double)sliding_arv_pkts_;
  1181. sliding_avg_pkt_size_ = (sliding_avg_pkt_size_*(sliding_arv_pkts_ - 1) + 8*cm_h->size())
  1182.     /(double)sliding_arv_pkts_; 
  1183. last_arrival_ = cur_time;
  1184. } else if (action == RESET_STATS) {
  1185. if (trace_hop_) {
  1186. fprintf(hop_trace_, "%ft", cur_time);
  1187. for (int i=1;i<=NO_CLASSES;i++) {
  1188. fprintf(hop_trace_, "%.8ft", max(current_loss_[i],0.00000001));
  1189. }
  1190. for (int i=1;i<=NO_CLASSES;i++) {
  1191. fprintf(hop_trace_, "%.8ft", max(sliding_class_delay_[i],0.00000001));
  1192. }
  1193. for (int i=1;i<=NO_CLASSES;i++) {
  1194. sliding_class_service_rate_[i] = sliding_serviced_bits_[i]/(double)MON_WINDOW_SIZE;
  1195. fprintf(hop_trace_, "%.0ft", max(sliding_class_service_rate_[i], 1));
  1196. sliding_serviced_pkts_[i] = 0;
  1197. sliding_serviced_bits_[i] = 0;
  1198. sliding_class_delay_[i] = 0;
  1199. sliding_class_service_rate_[i] = 0;
  1200. }
  1201. for (int i=1;i<=NO_CLASSES;i++) {
  1202. fprintf(hop_trace_, "%.0ft", (double)cls_[i]->length());
  1203. }
  1204. fprintf(hop_trace_, "n");
  1205. }
  1206. sliding_arv_pkts_ = 1;
  1207. sliding_arv_pkts_c[ip_h->prio()] = 1;
  1208. sliding_inter_ = cur_time - last_arrival_;
  1209. sliding_avg_pkt_size_ = 8*cm_h->size();
  1210. last_arrival_ = cur_time;
  1211. }
  1212. util_ = sliding_avg_pkt_size_ / (sliding_inter_*link_->bandwidth());
  1213. return;
  1214. }