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

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

通讯编程

开发平台：

Visual C++

tfrc.cc：源码内容
  1. /* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1999  International Computer Science Institute
  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 ACIRI, the AT&T 
  17.  *      Center for Internet Research at ICSI (the International Computer
  18.  *      Science Institute).
  19.  * 4. Neither the name of ACIRI nor of ICSI may be used
  20.  *    to endorse or promote products derived from this software without
  21.  *    specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY ICSI AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL ICSI OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  */
  36. #include <stdlib.h>
  37. #include <sys/types.h>
  38. #include <math.h>
  39.  
  40. #include "tfrc.h"
  41. #include "formula.h"
  42. #include "flags.h"
  44. int hdr_tfrc::offset_;
  45. int hdr_tfrc_ack::offset_;
  47. static class TFRCHeaderClass : public PacketHeaderClass {
  48. public:
  49. TFRCHeaderClass() : PacketHeaderClass("PacketHeader/TFRC",
  50.       sizeof(hdr_tfrc)) {
  51. bind_offset(&hdr_tfrc::offset_);
  52. }
  53. } class_tfrchdr;
  55. static class TFRC_ACKHeaderClass : public PacketHeaderClass {
  56. public:
  57. TFRC_ACKHeaderClass() : PacketHeaderClass("PacketHeader/TFRC_ACK",
  58.   sizeof(hdr_tfrc_ack)) {
  59. bind_offset(&hdr_tfrc_ack::offset_);
  60. }
  61. } class_tfrc_ackhdr;
  63. static class TfrcClass : public TclClass {
  64. public:
  65.    TfrcClass() : TclClass("Agent/TFRC") {}
  66.    TclObject* create(int, const char*const*) {
  67.      return (new TfrcAgent());
  68.    }
  69. } class_tfrc;
  72. TfrcAgent::TfrcAgent() : Agent(PT_TFRC), send_timer_(this), 
  73.  NoFeedbacktimer_(this), rate_(0), oldrate_(0), maxrate_(0)
  74. {
  75. bind("packetSize_", &size_);
  76. bind("rate_", &rate_);
  77. bind("df_", &df_);
  78. bind("tcp_tick_", &tcp_tick_);
  79. bind("ndatapack_", &ndatapack_);
  80. bind("ndatabytes_", &ndatabytes_);
  81. bind("true_loss_rate_", &true_loss_rate_);
  82. bind("srtt_init_", &srtt_init_);
  83. bind("rttvar_init_", &rttvar_init_);
  84. bind("rtxcur_init_", &rtxcur_init_);
  85. bind("rttvar_exp_", &rttvar_exp_);
  86. bind("T_SRTT_BITS", &T_SRTT_BITS);
  87. bind("T_RTTVAR_BITS", &T_RTTVAR_BITS);
  88. bind("InitRate_", &InitRate_);
  89. bind("overhead_", &overhead_);
  90. bind("ssmult_", &ssmult_);
  91. bind("bval_", &bval_);
  92. bind("ca_", &ca_);
  93. bind_bool("printStatus_", &printStatus_);
  94. bind_bool("conservative_", &conservative_);
  95. bind_bool("ecn_", &ecn_);
  96. bind("minrto_", &minrto_);
  97. bind("maxHeavyRounds_", &maxHeavyRounds_);
  98. bind("SndrType_", &SndrType_); 
  99. bind("scmult_", &scmult_);
  100. bind_bool("oldCode_", &oldCode_);
  101. bind("rate_init_", &rate_init_);
  102. // bind("standard_", &standard_);
  103. bind("rate_init_option_", &rate_init_option_);
  104. bind_bool("slow_increase_", &slow_increase_); 
  105. bind_bool("voip_", &voip_);
  106. bind("voip_max_pkt_rate_", &voip_max_pkt_rate_);
  107. bind("fsize_", &fsize_);
  108. bind_bool("useHeaders_", &useHeaders_);
  109. bind_bool("idleFix_", &idleFix_);
  110. bind("headersize_", &headersize_);
  111. seqno_ = -1;
  112. maxseq_ = 0;
  113. datalimited_ = 0;
  114. lastlimited_ = 0.0;
  115. last_pkt_time_ = 0.0;
  116. bind("maxqueue_", &maxqueue_);
  117. maxqueue_ = MAXSEQ;
  118. }
  120. /*
  121.  * Must convert bytes into packets. 
  122.  * If nbytes == -1, this corresponds to infinite send.  We approximate
  123.  * infinite by a very large number (MAXSEQ).
  124.  * For simplicity, when bytes are converted to packets, fractional packets 
  125.  * are always rounded up.  
  126.  */
  127. void TfrcAgent::sendmsg(int nbytes, const char* /*flags*/)
  128. {
  129.         if (nbytes == -1 && maxseq_ < MAXSEQ)
  130. advanceby(MAXSEQ - maxseq_);
  131.         else if (size_ > 0) {
  132. int npkts = int(nbytes/size_);
  133. npkts += (nbytes%size_ ? 1 : 0);
  134. // maxqueue was added by Tom Phelan, to control the
  135. //   transmit queue from the application.
  136. if ((maxseq_ - seqno_) < maxqueue_) {
  137. advanceby(npkts);
  138. }
  139. }
  140. }
  143. void TfrcAgent::advanceby(int delta)
  144. {
  145.    maxseq_ += delta;
  147. if (seqno_ == -1) {
  148. // if no packets hve been sent so far, call start. 
  149.    start(); 
  150. } else if (datalimited_ && maxseq_ > seqno_) {
  151. // We were data-limited - send a packet now!
  152. // The old code always waited for a timer to expire!!
  153. datalimited_ = 0;
  154. lastlimited_ = Scheduler::instance().clock();
  155. all_idle_ = 0;
  156. if (!oldCode_) {
  157. sendpkt();
  158. }
  159. }
  160. } 
  162. int TfrcAgent::command(int argc, const char*const* argv)
  163. {
  164. if (argc==2) {
  165. // are we an infinite sender?
  166. if ( (strcmp(argv[1],"start")==0) && (SndrType_ == 0)) {
  167. start();
  168. return TCL_OK;
  169. }
  170. if (strcmp(argv[1],"stop")==0) {
  171. stop();
  172. return TCL_OK;
  173. }
  174. }
  175.    if ((argc == 3) && (SndrType_ == 1)) {
  176. // or do we need an FTP type app? 
  177.      if (strcmp(argv[1], "advance") == 0) {
  178.              int newseq = atoi(argv[2]);
  179. // THIS ISN"T USED.
  180. // newseq: new sequence
  181. // seqno_: next sequence to be sent
  182. // maxseq_: max seq_  produced by app so far.
  183.              if (newseq > maxseq_)
  184.                   advanceby(newseq - maxseq_);
  185.              return (TCL_OK);
  186.      }
  187.      if (strcmp(argv[1], "advanceby") == 0) {
  188.        advanceby(atoi(argv[2]));
  189.        return (TCL_OK);
  190.      }
  191. }
  192. return (Agent::command(argc, argv));
  193. }
  195. void TfrcAgent::start()
  196. {
  197. seqno_=0;
  198. rate_ = InitRate_;
  199. delta_ = 0;
  200. oldrate_ = rate_;  
  201. rate_change_ = SLOW_START;
  202. UrgentFlag = 1;
  203. rtt_=0;  
  204. sqrtrtt_=1;
  205. rttcur_=1;
  206. tzero_ = 0;
  207. last_change_=0;
  208. maxrate_ = 0; 
  209. ss_maxrate_ = 0;
  210. ndatapack_=0;
  211. ndatabytes_ = 0;
  212. true_loss_rate_ = 0;
  213. active_ = 1; 
  214. round_id = 0;
  215. heavyrounds_ = 0;
  216. t_srtt_ = int(srtt_init_/tcp_tick_) << T_SRTT_BITS;
  217. t_rttvar_ = int(rttvar_init_/tcp_tick_) << T_RTTVAR_BITS;
  218. t_rtxcur_ = rtxcur_init_;
  219. rcvrate = 0 ;
  220. all_idle_ = 0;
  222. first_pkt_rcvd = 0 ;
  223. // send the first packet
  224. sendpkt();
  225. // ... at initial rate
  226. send_timer_.resched(size_/rate_);
  227. // ... and start timer so we can cut rate 
  228. // in half if we do not get feedback
  229. NoFeedbacktimer_.resched(2*size_/rate_); 
  230. }
  232. void TfrcAgent::stop()
  233. {
  234. active_ = 0;
  235. if (idleFix_) 
  236.   datalimited_ = 1;
  237. send_timer_.force_cancel();
  238. }
  240. void TfrcAgent::nextpkt()
  241. {
  242. double next = -1;
  243. double xrate = -1; 
  245. if (SndrType_ == 0) {
  246. sendpkt();
  247. }
  248. else {
  249. if (maxseq_ > seqno_) {
  250. sendpkt();
  251. } else
  252. datalimited_ = 1;
  253. if (debug_) {
  254.   double now = Scheduler::instance().clock();
  255. printf("Time: %5.2f Datalimited now.n", now);
  256. }
  257. }
  259. // If slow_increase_ is set, then during slow start, we increase rate
  260. // slowly - by amount delta per packet 
  261. if (slow_increase_ && round_id > 2 && (rate_change_ == SLOW_START) 
  262.        && (oldrate_+SMALLFLOAT< rate_)) {
  263. oldrate_ = oldrate_ + delta_;
  264. xrate = oldrate_;
  265. } else {
  266. if (ca_) {
  267. if (debug_) printf("SQRT: now: %5.2f factor: %5.2fn", Scheduler::instance().clock(), sqrtrtt_/sqrt(rttcur_));
  268. xrate = rate_ * sqrtrtt_/sqrt(rttcur_);
  269. } else
  270. xrate = rate_;
  271. }
  272. if (xrate > SMALLFLOAT) {
  273. next = size_/xrate;
  274. if (voip_) {
  275.         double min_interval = 1.0/voip_max_pkt_rate_;
  276.      if (next < min_interval)
  277. next = min_interval;
  278. }
  279. //
  280. // randomize between next*(1 +/- woverhead_) 
  281. //
  282. next = next*(2*overhead_*Random::uniform()-overhead_+1);
  283. if (next > SMALLFLOAT)
  284. send_timer_.resched(next);
  285.                 else 
  286. send_timer_.resched(SMALLFLOAT);
  287. }
  288. }
  290. void TfrcAgent::update_rtt (double tao, double now) 
  291. {
  292. /* the TCP update */
  293. t_rtt_ = int((now-tao) /tcp_tick_ + 0.5);
  294. if (t_rtt_==0) t_rtt_=1;
  295. if (t_srtt_ != 0) {
  296. register short rtt_delta;
  297. rtt_delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS);    
  298. if ((t_srtt_ += rtt_delta) <= 0)    
  299. t_srtt_ = 1;
  300. if (rtt_delta < 0)
  301. rtt_delta = -rtt_delta;
  302.    rtt_delta -= (t_rttvar_ >> T_RTTVAR_BITS);
  303.    if ((t_rttvar_ += rtt_delta) <= 0)  
  304. t_rttvar_ = 1;
  305. } else {
  306. t_srtt_ = t_rtt_ << T_SRTT_BITS;
  307. t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1);
  308. }
  309. t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) + t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;
  310. tzero_=t_rtxcur_;
  311.   if (tzero_ < minrto_) 
  312.    tzero_ = minrto_;
  314. /* fine grained RTT estimate for use in the equation */
  315. if (rtt_ > 0) {
  316. rtt_ = df_*rtt_ + ((1-df_)*(now - tao));
  317. sqrtrtt_ = df_*sqrtrtt_ + ((1-df_)*sqrt(now - tao));
  318. } else {
  319. rtt_ = now - tao;
  320. sqrtrtt_ = sqrt(now - tao);
  321. }
  322. rttcur_ = now - tao;
  323. }
  325. /*
  326.  * Receive a status report from the receiver.
  327.  */
  328. void TfrcAgent::recv(Packet *pkt, Handler *)
  329. {
  330. double now = Scheduler::instance().clock();
  331. hdr_tfrc_ack *nck = hdr_tfrc_ack::access(pkt);
  332. //double ts = nck->timestamp_echo;
  333. double ts = nck->timestamp_echo + nck->timestamp_offset;
  334. double rate_since_last_report = nck->rate_since_last_report;
  335. // double NumFeedback_ = nck->NumFeedback_;
  336. double flost = nck->flost; 
  337. int losses = nck->losses;
  338. true_loss_rate_ = nck->true_loss;
  340. round_id ++ ;
  341. UrgentFlag = 0;
  343. if (round_id > 1 && rate_since_last_report > 0) {
  344. /* compute the max rate for slow-start as two times rcv rate */ 
  345. ss_maxrate_ = 2*rate_since_last_report*size_;
  346. if (conservative_) { 
  347. if (losses >= 1) {
  348. /* there was a loss in the most recent RTT */
  349. if (debug_) printf("time: %5.2f losses: %d rate %5.2fn", 
  350.   now, losses, rate_since_last_report);
  351. maxrate_ = rate_since_last_report*size_;
  352. } else { 
  353. /* there was no loss in the most recent RTT */
  354. maxrate_ = scmult_*rate_since_last_report*size_;
  355. }
  356. if (debug_) printf("time: %5.2f losses: %d rate %5.2f maxrate: %5.2fn", now, losses, rate_since_last_report, maxrate_);
  357. } else 
  358. maxrate_ = 2*rate_since_last_report*size_;
  359. } else {
  360. ss_maxrate_ = 0;
  361. maxrate_ = 0; 
  362. }
  364. /* update the round trip time */
  365. update_rtt (ts, now);
  367. /* .. and estimate of fair rate */
  368. if (voip_ != 1) {
  369. // From RFC 3714:
  370. // The voip flow gets to send at the same rate as
  371. //  a TCP flow with 1460-byte packets.
  372. fsize_ = size_;
  373. }
  374. rcvrate = p_to_b(flost, rtt_, tzero_, fsize_, bval_);
  375. // rcvrate is in bytes per second, based on fairness with a    
  376. // TCP connection with the same packet size size_.       
  377. if (voip_) {
  378. // Subtract the bandwidth used by headers.
  379. double temp = rcvrate*(size_/(1.0*headersize_+size_));
  380. rcvrate = temp;
  381. }
  383. /* if we get no more feedback for some time, cut rate in half */
  384. double t = 2*rtt_ ; 
  385. if (t < 2*size_/rate_) 
  386. t = 2*size_/rate_ ; 
  387. NoFeedbacktimer_.resched(t);
  389. /* if we are in slow start and we just saw a loss */
  390. /* then come out of slow start */
  391. if (first_pkt_rcvd == 0) {
  392. first_pkt_rcvd = 1 ; 
  393. slowstart();
  394. nextpkt();
  395. }
  396. else {
  397. if (rate_change_ == SLOW_START) {
  398. if (flost > 0) {
  399. rate_change_ = OUT_OF_SLOW_START;
  400. oldrate_ = rate_ = rcvrate;
  401. }
  402. else {
  403. slowstart();
  404. nextpkt();
  405. }
  406. }
  407. else {
  408. if (rcvrate>rate_) 
  409. increase_rate(flost);
  410. else 
  411. decrease_rate ();
  412. }
  413. }
  414. if (printStatus_) {
  415. printf("time: %5.2f rate: %5.2fn", now, rate_);
  416. double packetrate = rate_ * rtt_ / size_;
  417. printf("time: %5.2f packetrate: %5.2fn", now, packetrate);
  418. double maxrate = maxrate_ * rtt_ / size_;
  419. printf("time: %5.2f maxrate: %5.2fn", now, maxrate);
  420. }
  421. Packet::free(pkt);
  422. }
  424. /*
  425.  * Calculate initial sending rate from RFC 3390.
  426.  */
  427. double TfrcAgent::rfc3390(int size)
  428. {
  429.         if (size_ <= 1095) {
  430.                 return (4.0);
  431.         } else if (size_ < 2190) {
  432.                 return (3.0);
  433.         } else {
  434.                 return (2.0);
  435.         }
  436. }
  438. /*
  439.  * Used in setting the initial rate.
  440.  * This is from TcpAgent::initial_wnd().
  441.  */
  442. double TfrcAgent::initial_rate()
  443. {
  444.         if (rate_init_option_ == 1) {
  445. // init_option = 1: static initial rate of rate_init_
  446.                 return (rate_init_);
  447.         }
  448.         else if (rate_init_option_ == 2) {
  449.                 // do initial rate according to RFC 3390.
  450. return (rfc3390(size_));
  451.         }
  452.         // XXX what should we return here???
  453.         fprintf(stderr, "Wrong number of rate_init_option_ %dn",
  454.                 rate_init_option_);
  455.         abort();
  456.         return (2.0); // XXX make msvc happy.
  457. }
  460. // ss_maxrate_ = 2*rate_since_last_report*size_;
  461. // rate_: the rate set from the last pass through slowstart()
  462. void TfrcAgent::slowstart () 
  463. {
  464. double now = Scheduler::instance().clock(); 
  465. double initrate = initial_rate()*size_/rtt_;
  466. // If slow_increase_ is set to true, delta is used so that 
  467. //  the rate increases slowly to new value over an RTT. 
  468. if (debug_) printf("SlowStart: round_id: %d rate: %5.2f ss_maxrate_: %5.2fn", round_id, rate_, ss_maxrate_);
  469. if (round_id <=1 || (round_id == 2 && initial_rate() > 1)) {
  470. // We don't have a good rate report yet, so keep to  
  471. //   the initial rate.      
  472. oldrate_ = rate_;
  473. if (rate_ < initrate) rate_ = initrate;
  474. delta_ = (rate_ - oldrate_)/(rate_*rtt_/size_);
  475. last_change_=now;
  476. } else if (ss_maxrate_ > 0) {
  477. if (idleFix_ && (datalimited_ || lastlimited_ > now - 1.5*rtt_)
  478.      && ss_maxrate_ < initrate) {
  479. // Datalimited recently, and maxrate is small.
  480. // Don't be limited by maxrate to less that initrate.
  481. oldrate_ = rate_;
  482. if (rate_ < initrate) rate_ = initrate;
  483. delta_ = (rate_ - oldrate_)/(rate_*rtt_/size_);
  484. last_change_=now;
  485. } else if (rate_ < ss_maxrate_ && 
  486.                     now - last_change_ > rtt_) {
  487. // Not limited by maxrate, and time to increase.
  488. // Multiply the rate by ssmult_, if maxrate allows.
  489. oldrate_ = rate_;
  490. if (ssmult_*rate_ > ss_maxrate_) 
  491. rate_ = ss_maxrate_;
  492. else rate_ = ssmult_*rate_;
  493. if (rate_ < size_/rtt_) 
  494. rate_ = size_/rtt_; 
  495. delta_ = (rate_ - oldrate_)/(rate_*rtt_/size_);
  496. last_change_=now;
  497. } else if (rate_ > ss_maxrate_) {
  498. // Limited by maxrate.  
  499. rate_ = oldrate_ = ss_maxrate_/2.0;
  500. delta_ = 0;
  501. last_change_=now;
  502. } 
  503. } else {
  504. // If we get here, ss_maxrate <= 0, so the receive rate is 0.
  505. // We should go back to a very small sending rate!!!
  506. oldrate_ = rate_;
  507. rate_ = size_/rtt_; 
  508. delta_ = 0;
  509.          last_change_=now;
  510. }
  511. if (debug_) printf("SlowStart: now: %5.2f rate: %5.2f delta: %5.2fn", now, rate_, delta_);
  512. if (printStatus_) {
  513. double rate = rate_ * rtt_ / size_;
  514.    printf("SlowStart: now: %5.2f rate: %5.2f ss_maxrate: %5.2f delta: %5.2fn", now, rate, ss_maxrate_, delta_);
  515. }
  516. }
  518. void TfrcAgent::increase_rate (double p)
  519. {               
  520.         double now = Scheduler::instance().clock();
  521.         double maximumrate;
  523. double mult = (now-last_change_)/rtt_ ;
  524. if (mult > 2) mult = 2 ;
  526. rate_ = rate_ + (size_/rtt_)*mult ;
  527. if (datalimited_ || lastlimited_ > now - 1.5*rtt_) {
  528. // Modified by Sally on 3/10/2006
  529. // If the sender has been datalimited, rate should be
  530. //   at least the initial rate, when increasing rate.
  531. double init_rate = initial_rate()*size_/rtt_;
  532.     maximumrate = (maxrate_>init_rate)?maxrate_:init_rate ;
  533.         } else {
  534.     maximumrate = (maxrate_>size_/rtt_)?maxrate_:size_/rtt_ ;
  535. }
  536. maximumrate = (maximumrate>rcvrate)?rcvrate:maximumrate;
  537. rate_ = (rate_ > maximumrate)?maximumrate:rate_ ;
  539.         rate_change_ = CONG_AVOID;  
  540.         last_change_ = now;
  541. heavyrounds_ = 0;
  542. if (debug_) printf("Increase: now: %5.2f rate: %5.2f lastlimited: %5.2f rtt: %5.2fn", now, rate_, lastlimited_, rtt_);
  543. if (printStatus_) {
  544. double rate = rate_ * rtt_ / size_;
  545. printf("Increase: now: %5.2f rate: %5.2f lastlimited: %5.2f rtt: %5.2fn", now, rate, lastlimited_, rtt_);
  546. }
  547. }       
  549. void TfrcAgent::decrease_rate () 
  550. {
  551. double now = Scheduler::instance().clock(); 
  552. rate_ = rcvrate;
  553. double maximumrate = (maxrate_>size_/rtt_)?maxrate_:size_/rtt_ ;
  555. // Allow sending rate to be greater than maximumrate
  556. //   (which is by default twice the receiving rate)
  557. //   for at most maxHeavyRounds_ rounds.
  558. if (rate_ > maximumrate)
  559. heavyrounds_++;
  560. else
  561. heavyrounds_ = 0;
  562. if (heavyrounds_ > maxHeavyRounds_) {
  563. rate_ = (rate_ > maximumrate)?maximumrate:rate_ ;
  564. }
  566. rate_change_ = RATE_DECREASE;
  567. last_change_ = now;
  568. if (debug_) printf("Decrease: now: %5.2f rate: %5.2f rtt: %5.2fn", now, rate_, rtt_);
  569. if (printStatus_) {
  570. double rate = rate_ * rtt_ / size_;
  571. printf("Decrease: now: %5.2f rate: %5.2f rtt: %5.2fn", now, rate, rtt_);
  572. }
  573. }
  575. void TfrcAgent::sendpkt()
  576. {
  577. if (active_) {
  578. double now = Scheduler::instance().clock(); 
  579. Packet* p = allocpkt();
  580. hdr_tfrc *tfrch = hdr_tfrc::access(p);
  581. hdr_flags* hf = hdr_flags::access(p);
  582. if (ecn_) {
  583. hf->ect() = 1;  // ECN-capable transport
  584. }
  585. tfrch->seqno=seqno_++;
  586. tfrch->timestamp=Scheduler::instance().clock();
  587. tfrch->rtt=rtt_;
  588. tfrch->tzero=tzero_;
  589. tfrch->rate=rate_;
  590. tfrch->psize=size_;
  591. tfrch->fsize=fsize_;
  592. tfrch->UrgentFlag=UrgentFlag;
  593. tfrch->round_id=round_id;
  594. ndatapack_++;
  595. ndatabytes_ += size_;
  596. if (useHeaders_ == true) {
  597. hdr_cmn::access(p)->size() += headersize_;
  598. }
  599. last_pkt_time_ = now;
  600. send(p, 0);
  601. }
  602. }
  605. /*
  606.  * RFC 3448:
  607.  * "If the sender has been idle since this nofeedback timer was set and
  608.  * X_recv is less than four packets per round-trip time, then X_recv
  609.  * should not be halved in response to the timer expiration.  This
  610.  * ensures that the allowed sending rate is never reduced to less than
  611.  * two packets per round-trip time as a result of an idle period."
  612.  */
  613.  
  614. void TfrcAgent::reduce_rate_on_no_feedback()
  615. {
  616. double now = Scheduler::instance().clock();
  617. if (rate_change_ != SLOW_START)
  618. // "if" statement added by Sally on 9/25/06,
  619. // so that an idle report doesn't kick us out of
  620. // slow-start!
  621. rate_change_ = RATE_DECREASE; 
  622. if (oldCode_ || (!all_idle_ && !datalimited_)) {
  623. // if we are not datalimited
  624. rate_*=0.5;
  625. } else if ((datalimited_ || all_idle_) && rate_init_option_ == 1) { 
  626. // all_idle_: the sender has been datalimited since the 
  627. //    timer was set
  628. //  Don't reduce rate below rate_init_ * size_/rtt_.
  629.                 if (rate_ > 2.0 * rate_init_ * size_/rtt_ ) {
  630.                         rate_*=0.5;
  631.                 } 
  632. } else if ((datalimited_ || all_idle_) && rate_init_option_ == 2) {
  633.                 // Don't reduce rate below the RFC3390 rate.
  634.                 if (rate_ > 2.0 * rfc3390(size_) * size_/rtt_ ) {
  635.                         rate_*=0.5;
  636.                 } else if ( rate_ > rfc3390(size_) * size_/rtt_ ) {
  637.                         rate_ = rfc3390(size_) * size_/rtt_;
  638.                 }
  639.         }
  640. if (debug_) printf("NO FEEDBACK: time: %5.2f rate: %5.2f all_idle: %dn", now, rate_, all_idle_);
  641. UrgentFlag = 1;
  642. round_id ++ ;
  643. double t = 2*rtt_ ; 
  644. // Set the nofeedback timer.
  645. if (t < 2*size_/rate_) 
  646. t = 2*size_/rate_ ; 
  647. NoFeedbacktimer_.resched(t);
  648. if (datalimited_) {
  649. all_idle_ = 1;
  650. if (debug_) printf("Time: %5.2f Datalimited now.n", now);
  651. }
  652. nextpkt();
  653. }
  655. void TfrcSendTimer::expire(Event *) {
  656.    a_->nextpkt();
  657. }
  659. void TfrcNoFeedbackTimer::expire(Event *) {
  660. a_->reduce_rate_on_no_feedback ();
  661. // TODO: if the first (SYN) packet was dropped, then don't use
  662. //   the larger initial rates from RFC 3390:
  663.         // if (highest_ack_ == -1 && wnd_init_option_ == 2)
  664. //     wnd_init_option_ = 1;
  666. }