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

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

通讯编程

开发平台：

Visual C++

chost.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 Daedalus 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.  *
  34.  * $Header: /cvsroot/nsnam/ns-2/tcp/chost.cc,v 1.13 2000/09/01 03:04:05 haoboy Exp $
  35.  */
  37. /*
  38.  * Functions invoked by TcpSessionAgent
  39.  */
  40. #include "nilist.h"
  41. #include "chost.h"
  42. #include "tcp-int.h"
  43. #include "random.h"
  45. CorresHost::CorresHost() : slink(), TcpFsAgent(),
  46. lastackTS_(0), dontAdjustOwnd_(0), dontIncrCwnd_(0), rexmtSegCount_(0),
  47. connWithPktBeforeFS_(NULL)
  48. {
  49. nActive_ = nTimeout_ = nFastRec_ = 0;
  50. ownd_ = 0;
  51. owndCorrection_ = 0;
  52. closecwTS_ = 0;
  53. connIter_ = new Islist_iter<IntTcpAgent> (conns_);
  54. rtt_seg_ = NULL;
  55. }
  58. /*
  59.  * Open up the congestion window.
  60.  */
  61. void 
  62. CorresHost::opencwnd(int /*size*/, IntTcpAgent *sender)
  63. {
  64. if (cwnd_ < ssthresh_) {
  65. /* slow-start (exponential) */
  66. cwnd_ += 1;
  67. } else {
  68. /* linear */
  69. //double f;
  70. if (!proxyopt_) {
  71. switch (wnd_option_) {
  72. case 0:
  73. if ((count_ = count_ + winInc_) >= cwnd_) {
  74. count_ = 0;
  75. cwnd_ += winInc_;
  76. }
  77. break;
  78. case 1:
  79. /* This is the standard algorithm. */
  80. cwnd_ += winInc_ / cwnd_;
  81. break;
  82. default:
  83. #ifdef notdef
  84. /*XXX*/
  85. error("illegal window option %d", wnd_option_);
  86. #endif
  87. abort();
  88. }
  89. } else { // proxy
  90. switch (wnd_option_) {
  91. case 0: 
  92. case 1:
  93. if (sender->highest_ack_ >= sender->wndIncSeqno_) {
  94. cwnd_ += winInc_;
  95. sender->wndIncSeqno_ = 0;
  96. }
  97. break;
  98. default:
  99. #ifdef notdef
  100. /*XXX*/
  101. error("illegal window option %d", wnd_option_);
  102. #endif
  103. abort();
  104. }
  105. }
  106. }
  107. // if maxcwnd_ is set (nonzero), make it the cwnd limit
  108. if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
  109. cwnd_ = maxcwnd_;
  111. return;
  112. }
  114. void 
  115. CorresHost::closecwnd(int how, double ts, IntTcpAgent *sender)
  116. {
  117. if (proxyopt_) {
  118. if (!sender || ts > sender->closecwTS_)
  119. closecwnd(how, sender);
  120. }
  121. else {
  122. if (ts > closecwTS_)
  123. closecwnd(how, sender);
  124. }
  125. }
  127. void 
  128. CorresHost::closecwnd(int how, IntTcpAgent *sender)
  129. {
  130. int sender_ownd = 0;
  131. if (sender)
  132. sender_ownd = sender->maxseq_ - sender->highest_ack_;
  133. closecwTS_ = Scheduler::instance().clock();
  134. if (proxyopt_) {
  135. if (sender)
  136. sender->closecwTS_ = closecwTS_;
  137. how += 10;
  138. }
  139. switch (how) {
  140. case 0:
  141. case 10:
  142. /* timeouts */
  144. /* 
  145.  * XXX we use cwnd_ instead of ownd_ here, which may not be
  146.  * appropriate if the sender does not fully utilize the
  147.  * available congestion window (ownd_ < cwnd_).
  148.  */
  149. ssthresh_ = int(cwnd_ * winMult_);
  150. cwnd_ = int(wndInit_);
  151. break;
  153. case 1:
  154. /* Reno dup acks, or after a recent congestion indication. */
  156. /* 
  157.  * XXX we use cwnd_ instead of ownd_ here, which may not be
  158.  * appropriate if the sender does not fully utilize the
  159.  * available congestion window (ownd_ < cwnd_).
  160.  */
  161. cwnd_ *= winMult_;
  162. ssthresh_ = int(cwnd_);
  163. if (ssthresh_ < 2)
  164. ssthresh_ = 2;
  165. break;
  167. case 11:
  168. /* Reno dup acks, or after a recent congestion indication. */
  169. /* XXX fix this -- don't make it dependent on ownd */
  170. cwnd_ = ownd_ - sender_ownd*(1-winMult_);
  171. ssthresh_ = int(cwnd_);
  172. if (ssthresh_ < 2)
  173. ssthresh_ = 2;
  174. break;
  176. case 3:
  177. case 13:
  178. /* idle time >= t_rtxcur_ */
  179. cwnd_ = wndInit_;
  180. break;
  182. default:
  183. abort();
  184. }
  185. fcnt_ = 0.;
  186. count_ = 0;
  187. if (sender)
  188. sender->count_ = 0;
  189. }
  191. Segment* 
  192. CorresHost::add_pkts(int /*size*/, int seqno, int sessionSeqno, int daddr, int dport, 
  193.      int sport, double ts, IntTcpAgent *sender)
  194. {
  195. class Segment *news;
  197. ownd_ += 1;
  198. news = new Segment;
  199. news->seqno_ = seqno;
  200. news->sessionSeqno_ = sessionSeqno;
  201. news->daddr_ = daddr;
  202. news->dport_ = dport;
  203. news->sport_ = sport;
  204. news->ts_ = ts;
  205. news->size_ = 1;
  206. news->dupacks_ = 0;
  207. news->later_acks_ = 0;
  208. news->thresh_dupacks_ = 0;
  209. news->partialack_ = 0;
  210. news->rxmitted_ = 0;
  211. news->sender_ = sender;
  212. seglist_.append(news);
  213. return news;
  214. }
  216. void
  217. CorresHost::adjust_ownd(int size) 
  218. {
  219. if (double(owndCorrection_) < size)
  220. ownd_ -= min(double(ownd_), size - double(owndCorrection_));
  221. owndCorrection_ -= min(double(owndCorrection_),size);
  222. if (double(ownd_) < -0.5 || double(owndCorrection_ < -0.5))
  223. printf("In adjust_ownd(): ownd_ = %g  owndCorrection_ = %gn", double(ownd_), double(owndCorrection_));
  224. }
  226. int
  227. CorresHost::clean_segs(int /*size*/, Packet *pkt, IntTcpAgent *sender, int sessionSeqno, int amt_data_acked)
  228. { 
  229.     Segment *cur, *prev=NULL, *newseg;
  230.     int i;
  231.     //int rval = -1;
  233.     /* remove all acked pkts from list */
  234.     int latest_susp_loss = rmv_old_segs(pkt, sender, amt_data_acked);
  235.     /* 
  236.      * XXX If no new data is acked and the last time we shrunk the window 
  237.      * covers the most recent suspected loss, update the estimate of the amount
  238.      * of outstanding data.
  239.      */
  240.     if (amt_data_acked == 0 && latest_susp_loss <= recover_ && 
  241. !dontAdjustOwnd_ && last_cwnd_action_ != CWND_ACTION_TIMEOUT) {
  242.     owndCorrection_ += min(double(ownd_),1);
  243.     ownd_ -= min(double(ownd_),1);
  244.     }
  245.     /*
  246.      * A pkt is a candidate for retransmission if it is the leftmost one in the
  247.      * unacked window for the connection AND has at least numdupacks_
  248.      * dupacks/later acks AND (at least one dupack OR a later packet also
  249.      * with the threshold number of dup/later acks). A pkt is also a candidate
  250.      * for immediate retransmission if it has partialack_ set, indicating that
  251.      * a partial new ack has been received for it.
  252.      */
  254.     for (i=0; i < rexmtSegCount_; i++) {
  255.     int remove_flag = 0;
  256.     /* 
  257.      * curArray_ only contains segments that are the first oldest
  258.      * unacked segments of their connection (i.e., they are at the left
  259.      * edge of their window) and have either received a
  260.      * partial ack and/or have received at least cur->numdupacks_
  261.      * dupacks/later acks. Thus, segments in curArray_ have a high
  262.      * probability (but not certain) of being eligible for 
  263.      * retransmission. Using curArray_ avoids having to scan
  264.      * through all the segments.
  265.      */
  266.     cur = curArray_[i];
  267.     prev = prevArray_[i];
  268.     if (cur->partialack_ || cur->dupacks_ > 0 || 
  269. cur->sender_->num_thresh_dupack_segs_ > 1 ) {
  270.     if (cur->thresh_dupacks_) {
  271.     cur->thresh_dupacks_ = 0;
  272.     cur->sender_->num_thresh_dupack_segs_--;
  273.     }
  274.     if (cur->sessionSeqno_ <= recover_ && 
  275. last_cwnd_action_ != CWND_ACTION_TIMEOUT /* XXX 2 */)
  276.     dontAdjustOwnd_ = 1;
  277.     if ((cur->sessionSeqno_ > recover_) || 
  278. (last_cwnd_action_ == CWND_ACTION_TIMEOUT /* XXX 2 */)
  279. || (proxyopt_ && cur->seqno_ > cur->sender_->recover_)
  280. || (proxyopt_ && cur->sender_->last_cwnd_action_ == CWND_ACTION_TIMEOUT /* XXX 2 */)) { 
  281.     /* new loss window */
  282.     closecwnd(1, cur->ts_, cur->sender_);
  283.     recover_ = sessionSeqno - 1;
  284.     last_cwnd_action_ = CWND_ACTION_DUPACK /* XXX 1 */;
  285.     cur->sender_->recover_ = cur->sender_->maxseq_;
  286.     cur->sender_->last_cwnd_action_ = 
  287.     CWND_ACTION_DUPACK /* XXX 1 */;
  288.     dontAdjustOwnd_ = 0;
  289.     }
  290.     if ((newseg = cur->sender_->rxmit_last(TCP_REASON_DUPACK, 
  291.    cur->seqno_, cur->sessionSeqno_, cur->ts_))) {
  292.     newseg->rxmitted_ = 1;
  293.     adjust_ownd(cur->size_);
  294.     if (!dontAdjustOwnd_) {
  295.     owndCorrection_ += 
  296.     min(double(ownd_),cur->dupacks_);
  297.     ownd_ -= min(double(ownd_),cur->dupacks_);
  298.     }
  299.     seglist_.remove(cur, prev);
  300.     remove_flag = 1;
  301.     delete cur;
  302.     }
  303.     /* 
  304.      * if segment just removed used to be the one just previous
  305.      * to the next segment in the array, update prev for the
  306.      * next segment
  307.      */
  308.     if (remove_flag && cur == prevArray_[i+1])
  309.     prevArray_[i+1] = prev;
  310.     }
  311.     }
  312.     rexmtSegCount_ = 0;
  313.     return(0);
  314. }
  315.     
  317. int
  318. CorresHost::rmv_old_segs(Packet *pkt, IntTcpAgent *sender, int amt_data_acked)
  319. {
  320. Islist_iter<Segment> seg_iter(seglist_);
  321. Segment *cur, *prev=0;
  322. int found = 0;
  323. int done = 0;
  324. int new_data_acked = 0;
  325. int partialack = 0;
  326. int latest_susp_loss = -1;
  327. hdr_tcp *tcph = hdr_tcp::access(pkt);
  329. if (tcph->ts_echo() > lastackTS_)
  330. lastackTS_ = tcph->ts_echo();
  332. while (((cur = seg_iter()) != NULL) &&
  333.        (!done || tcph->ts_echo() > cur->ts_)) {
  334. int remove_flag = 0;
  335. /* ack for older pkt of another connection */
  336. if (sender != cur->sender_ && tcph->ts_echo() > cur->ts_) { 
  337. if (!disableIntLossRecov_)
  338. cur->later_acks_++;
  339. latest_susp_loss = 
  340. max(latest_susp_loss,cur->sessionSeqno_);
  341. dontIncrCwnd_ = 1;
  342. } 
  343. /* ack for same connection */
  344. else if (sender == cur->sender_) {
  345. /* found packet acked */
  346. if (tcph->seqno() == cur->seqno_ && 
  347.     tcph->ts_echo() == cur->ts_) 
  348. found = 1;
  349. /* higher ack => clean up acked packets */
  350. if (tcph->seqno() >= cur->seqno_) {
  351. adjust_ownd(cur->size_);
  352. seglist_.remove(cur, prev);
  353. remove_flag = 1;
  354. new_data_acked += cur->size_;
  355. if (new_data_acked >= amt_data_acked)
  356. done = 1;
  357. if (prev == cur) 
  358. prev = NULL;
  359. if (cur == rtt_seg_)
  360. rtt_seg_ = NULL;
  361. delete cur;
  362. if (seg_iter.get_cur() && prev)
  363. seg_iter.set_cur(prev);
  364. else if (seg_iter.get_cur())
  365. seg_iter.set_cur(seg_iter.get_last());
  366. } 
  367. /* partial new ack => rexmt immediately */
  368. /* XXX should we check recover for session? */
  369. else if (amt_data_acked > 0 && 
  370.  tcph->seqno() == cur->seqno_-1 &&
  371.  cur->seqno_ <= sender->recover_ &&
  372.  sender->last_cwnd_action_ == CWND_ACTION_DUPACK) {
  373. cur->partialack_ = 1;
  374. partialack = 1;
  375. latest_susp_loss = 
  376. max(latest_susp_loss,cur->sessionSeqno_);
  377. if (new_data_acked >= amt_data_acked)
  378. done = 1;
  379. dontIncrCwnd_ = 1;
  380. }
  381. /* 
  382.  * If no new data has been acked AND this segment has
  383.  * not been retransmitted before AND the ack indicates 
  384.  * that this is the next segment to be acked, then
  385.  * increment dupack count.
  386.  */
  387. else if (!amt_data_acked && !cur->rxmitted_ &&
  388.  tcph->seqno() == cur->seqno_-1) {
  389. cur->dupacks_++;
  390. latest_susp_loss = 
  391. max(latest_susp_loss,cur->sessionSeqno_);
  392. done = 1;
  393. dontIncrCwnd_ = 1;
  394. } 
  395. }
  396. if (cur->dupacks_+cur->later_acks_ >= sender->numdupacks_ &&
  397.     !cur->thresh_dupacks_) {
  398. cur->thresh_dupacks_ = 1;
  399. cur->sender_->num_thresh_dupack_segs_++;
  400. }
  402. if (amt_data_acked==0 && tcph->seqno()==cur->seqno_-1)
  403. done = 1;
  404. /* XXX we could check for rexmt candidates here if we ignore 
  405.    the num_thresh_dupack_segs_ check */
  406. if (!remove_flag &&
  407.     cur->seqno_ == cur->sender_->highest_ack_ + 1 &&
  408.     (cur->dupacks_ + cur->later_acks_ >= sender->numdupacks_ ||
  409.      cur->partialack_)) {
  410. curArray_[rexmtSegCount_] = cur;
  411. prevArray_[rexmtSegCount_] = prev;
  412. rexmtSegCount_++;
  413. }
  414. if (!remove_flag)
  415. prev = cur;
  416. }
  417. /* partial ack => terminate fast start mode */
  418. if (partialack && fs_enable_ && fs_mode_) {
  419. timeout(TCP_TIMER_RESET);
  420. rexmtSegCount_ = 0;
  421. }
  422. return latest_susp_loss;
  423. }
  425. void
  426. CorresHost::add_agent(IntTcpAgent *agent, int /*size*/, double winMult, 
  427.       int winInc, int /*ssthresh*/)
  428. {
  429. if (nActive_ >= MAX_PARALLEL_CONN) {
  430. printf("In add_agent(): reached limit of number of parallel conn (%d); returningn", nActive_);
  431. return;
  432. }
  433. nActive_++;
  434. if ((!fixedIw_ && nActive_ > 1) || cwnd_ == 0)
  435. cwnd_ += 1; /* XXX should this be done? */
  436. wndInit_ = 1;
  437. winMult_ = winMult;
  438. winInc_ = winInc;
  439. /* ssthresh_ = ssthresh;*/
  440. conns_.append(agent);
  441. }
  443. int
  444. CorresHost::ok_to_snd(int /*size*/)
  445. {
  446. if (ownd_ <= -0.5)
  447. printf("In ok_to_snd(): ownd_ = %g  owndCorrection_ = %gn", double(ownd_), double(owndCorrection_));
  448. return (cwnd_ >= ownd_+1);
  449. }