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

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

通讯编程

开发平台：

Visual C++

tcp-session.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/tcp-session.cc,v 1.18 2000/09/01 03:04:07 haoboy Exp $
  35.  */
  37. #include <stdlib.h>
  38. #include <math.h>
  39. #include "ip.h"
  40. #include "flags.h"
  41. #include "random.h"
  42. #include "template.h"
  43. #include "nilist.h"
  44. #include "tcp.h"
  45. #include "tcp-int.h"
  46. #include "tcp-session.h"
  48. /*
  49.  * We separate TCP functionality into two parts: that having to do with 
  50.  * providing a reliable, ordered byte-stream service, and that having to do with
  51.  * congestion control and loss recovery. The former is done on a per-connection
  52.  * basis and is implemented as part of IntTcpAgent ("integrated TCP"). The 
  53.  * latter is done in an integrated fashion across multiple TCP connections, and
  54.  * is implemented as part of TcpSessionAgent ("TCP session"). TcpSessionAgent is
  55.  * derived from CorresHost ("correspondent host"), which keeps track of the 
  56.  * state of all TCP (TCP/Int) connections to a host that it is corresponding 
  57.  * with.
  58.  *
  59.  * The motivation for this separation of functionality is to make an ensemble of
  60.  * connection more well-behaved than a set of independent TCP connections.
  61.  * The packet loss rate is cut down and the chances of losses being recovered 
  62.  * via data-driven techniques (rather than via timeouts) is improved. At the 
  63.  * same time, we do not introduce any unnecessary coupling between the 
  64.  * logically-independent byte-streams that the set of connections represents. 
  65.  * This is in contrast to the coupling that is inherent in the multiplexing at 
  66.  * the application layer of multiple byte-streams onto a single TCP connection.
  67.  *
  68.  * For questions/comments, please contact:
  69.  *   Venkata N. Padmanabhan (padmanab@cs.berkeley.edu)
  70.  *   http://www.cs.berkeley.edu/~padmanab
  71.  */
  73. static class TcpSessionClass : public TclClass {
  74. public:
  75. TcpSessionClass() : TclClass("Agent/TCP/Session") {}
  76. TclObject* create(int, const char*const*) {
  77. return (new TcpSessionAgent()); 
  78. }
  79. } class_tcpsession;
  81. TcpSessionAgent::TcpSessionAgent() : CorresHost(), 
  82. rtx_timer_(this), burstsnd_timer_(this), sessionSeqno_(0),
  83. last_send_time_(-1), curConn_(0), numConsecSegs_(0), 
  84. schedDisp_(FINE_ROUND_ROBIN), wtSum_(0), dynWtSum_(0) 
  85. {
  86. bind("ownd_", &ownd_);
  87. bind("owndCorr_", &owndCorrection_);
  88. bind_bool("proxyopt_", &proxyopt_);
  89. bind_bool("fixedIw_", &fixedIw_);
  90. bind("schedDisp_", &schedDisp_);
  91. bind_bool("disableIntLossRecov_", &disableIntLossRecov_);
  93. sessionList_.append(this);
  94. }
  96. int
  97. TcpSessionAgent::command(int argc, const char*const* argv)
  98. {
  99. if (argc == 2) {
  100. if (!strcmp(argv[1], "resetwt")) {
  101. Islist_iter<IntTcpAgent> conn_iter(conns_);
  102. IntTcpAgent *tcp;
  104. while ((tcp = conn_iter()) != NULL) 
  105. tcp->wt_ = 1;
  106. wtSum_ = conn_iter.count();
  107. return (TCL_OK);
  108. }
  109. }
  110. return (CorresHost::command(argc, argv));
  111. }
  113. void
  114. SessionRtxTimer::expire(Event*)
  115. {
  116. a_->timeout(TCP_TIMER_RTX);
  117. }
  119. void
  120. SessionResetTimer::expire(Event*)
  121. {
  122. a_->timeout(TCP_TIMER_RESET);
  123. }
  125. void
  126. SessionBurstSndTimer::expire(Event*)
  127. {
  128. a_->timeout(TCP_TIMER_BURSTSND);
  129. }
  131. void
  132. TcpSessionAgent::reset_rtx_timer(int /*mild*/, int backoff)
  133. {
  134. if (backoff)
  135. rtt_backoff();
  136. set_rtx_timer();
  137. rtt_active_ = 0;
  138. }
  140. void
  141. TcpSessionAgent::set_rtx_timer()
  142. {
  143. if (rtx_timer_.status() == TIMER_PENDING)
  144. rtx_timer_.cancel();
  145. if (reset_timer_.status() == TIMER_PENDING)
  146. reset_timer_.cancel();
  147. if (fs_enable_ && fs_mode_)
  148. reset_timer_.resched(rtt_exact_timeout());
  149. else
  150. rtx_timer_.resched(rtt_timeout());
  151. }
  153. void
  154. TcpSessionAgent::cancel_rtx_timer()
  155. {
  156. rtx_timer_.force_cancel();
  157. reset_timer_.force_cancel();
  158. }
  160. void
  161. TcpSessionAgent::cancel_timers()
  162. {
  163. rtx_timer_.force_cancel();
  164. reset_timer_.force_cancel();
  165. burstsnd_timer_.force_cancel();
  166. delsnd_timer_.force_cancel();
  167. }
  169. int
  170. TcpSessionAgent::fs_pkt() {
  171. return (fs_enable_ && fs_mode_ && sessionSeqno_-1 >= fs_startseq_ &&
  172. sessionSeqno_-1 < fs_endseq_);
  173. }
  175. void
  176. TcpSessionAgent::rtt_update_exact(double tao)
  177. {
  178. double g = 1/8; /* gain used for smoothing rtt */
  179. double h = 1/4; /* gain used for smoothing rttvar */
  180. double delta;
  182. if (t_exact_srtt_ != 0) {
  183. delta = tao - t_exact_srtt_;
  184. if (delta < 0)
  185. delta = -delta;
  186. /* update the fine-grained estimate of the smoothed RTT */
  187. if (t_exact_srtt_ != 0) 
  188. t_exact_srtt_ = g*tao + (1-g)*t_exact_srtt_;
  189. else
  190. t_exact_srtt_ = tao;
  191. /* update the fine-grained estimate of mean deviation in RTT */
  192. delta -= t_exact_rttvar_;
  193. t_exact_rttvar_ += h*delta;
  194. }
  195. else {
  196. t_exact_srtt_ = tao;
  197. t_exact_rttvar_ = tao/2;
  198. }
  199. }
  201. void
  202. TcpSessionAgent::newack(Packet *pkt) 
  203. {
  204. double now = Scheduler::instance().clock();
  205. Islist_iter<Segment> seg_iter(seglist_);
  206. hdr_tcp *tcph = hdr_tcp::access(pkt);
  207. hdr_flags *fh = hdr_flags::access(pkt);
  209. if (!fh->no_ts_) {
  210. /* if the timestamp option is being used */
  211. if (ts_option_) {
  212. rtt_update(now - tcph->ts_echo());
  213. rtt_update_exact(now - tcph->ts_echo());
  214. }
  215. /* if segment being timed just got acked */
  216. if (rtt_active_ && rtt_seg_ == NULL) {
  217. t_backoff_ = 1;
  218. rtt_active_ = 0;
  219. if (!ts_option_)
  220. rtt_update(now - rtt_ts_);
  221. }
  222. }
  223. if (seg_iter.count() > 0)
  224. set_rtx_timer();
  225. else
  226. cancel_rtx_timer();
  227. }
  229. void
  230. TcpSessionAgent::timeout(int tno)
  231. {
  232. if (tno == TCP_TIMER_BURSTSND)
  233. send_much(NULL,0,0);
  234. else if (tno == TCP_TIMER_RESET) {
  235. Islist_iter<Segment> seg_iter(seglist_);
  236. Segment *curseg;
  237. Islist_iter<IntTcpAgent> conn_iter(conns_);
  238. IntTcpAgent *curconn;
  240. fs_mode_ = 0;
  241. if (seg_iter.count() == 0 && !slow_start_restart_) {
  242. return;
  243. }
  244. recover_ = sessionSeqno_ - 1;
  245. last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  246. ownd_ = 0;
  247. owndCorrection_ = 0;
  248. while ((curconn = conn_iter()) != NULL) {
  249. curconn->maxseq_ = curconn->highest_ack_;
  250. curconn->t_seqno_ = curconn->highest_ack_ + 1;
  251. curconn->recover_ = curconn->maxseq_;
  252. curconn->last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  253. }
  254. while ((curseg = seg_iter()) != NULL) {
  255. /* XXX exclude packets sent "recently"? */
  256. curseg->size_ = 0;
  257. }
  259. /* 
  260.  * If first pkt sent before fast start has not gotten through, 
  261.  * treat this as a regular rtx timeout. Otherwise, close cwnd
  262.  * and reset timer but don't back off timer.
  263.  */
  264. if (connWithPktBeforeFS_) {
  265. connWithPktBeforeFS_ = NULL;
  266. timeout(TCP_TIMER_RTX);
  267. }
  268. else {
  269. slowdown(CLOSE_CWND_INIT);
  270. reset_rtx_timer(0,0);
  271. send_much(NULL, 0, TCP_REASON_TIMEOUT);
  272. }
  273. }
  274. else if (tno == TCP_TIMER_RTX) {
  275. Islist_iter<Segment> seg_iter(seglist_);
  276. Segment *curseg;
  277. Islist_iter<IntTcpAgent> conn_iter(conns_);
  278. IntTcpAgent *curconn;
  280. if (seg_iter.count() == 0 && !slow_start_restart_) {
  281. return;
  282. }
  283. recover_ = sessionSeqno_ - 1;
  284. last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  285. if (seg_iter.count() == 0 && restart_bugfix_) {
  286. slowdown(CLOSE_CWND_INIT);
  287. reset_rtx_timer(0,0);
  288. }
  289. else {
  290. slowdown(CLOSE_CWND_RESTART|CLOSE_SSTHRESH_HALF);
  291. reset_rtx_timer(0,1);
  292. }
  293. nrexmit_++;
  294. ownd_ = 0;
  295. owndCorrection_ = 0;
  296. while ((curconn = conn_iter()) != NULL) {
  297. curconn->t_seqno_ = curconn->highest_ack_ + 1;
  298. curconn->recover_ = curconn->maxseq_;
  299. curconn->last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  300. }
  301. while ((curseg = seg_iter()) != NULL) {
  302. /* XXX exclude packets sent "recently"? */
  303. curseg->size_ = 0;
  304. }
  306. send_much(NULL, 0, TCP_REASON_TIMEOUT);
  307. }
  308. else
  309. printf("TcpSessionAgent::timeout(): ignoring unknown timer %dn", tno);
  310. }
  312. Segment* 
  313. TcpSessionAgent::add_pkts(int size, int seqno, int sessionSeqno, int daddr, 
  314.   int dport, int sport, double ts, IntTcpAgent *sender)
  315. {
  316. /*
  317.  * set rtx timer afresh either if it is not set now or if there are no 
  318.  * data packets outstanding at this time
  319.  */
  320. if (!(rtx_timer_.status() == TIMER_PENDING) || seglist_.count() == 0)
  321. set_rtx_timer();
  322. last_seg_sent_ = CorresHost::add_pkts(size, seqno, sessionSeqno, daddr, dport, sport, ts, sender);
  323. return last_seg_sent_;
  324. }
  326. void
  327. TcpSessionAgent::add_agent(IntTcpAgent *agent, int size, double winMult, 
  328.    int winInc, int ssthresh)
  329. {
  330. CorresHost::add_agent(agent,size,winMult,winInc,ssthresh);
  331. wtSum_ += agent->wt_;
  332. reset_dyn_weights();
  333. }
  335. int
  336. TcpSessionAgent::window()
  337. {
  338. if (maxcwnd_ == 0)
  339. return (int(cwnd_));
  340. else
  341. return (int(min(cwnd_,maxcwnd_)));
  342. }
  344. void
  345. TcpSessionAgent::set_weight(IntTcpAgent *tcp, int wt)
  346. {
  347. wtSum_ -= tcp->wt_;
  348. tcp->wt_ = wt;
  349. wtSum_ += tcp->wt_;
  350. }
  352. void
  353. TcpSessionAgent::reset_dyn_weights()
  354. {
  355. IntTcpAgent *tcp;
  356. Islist_iter<IntTcpAgent> conn_iter(conns_);
  358. while ((tcp = conn_iter()) != NULL)
  359. tcp->dynWt_ = tcp->wt_;
  360. dynWtSum_ = wtSum_;
  361. }
  363. IntTcpAgent *
  364. TcpSessionAgent::who_to_snd(int how)
  365. {
  366. int i = 0;
  367. switch (how) {
  368. /* fine-grained interleaving of connections (per pkt) */
  369. case FINE_ROUND_ROBIN: { 
  370. IntTcpAgent *next;
  371. int wtOK = 0;
  373. if (dynWtSum_ == 0) 
  374. reset_dyn_weights();
  375. do {
  376. wtOK = 0;
  377. if ((next = (*connIter_)()) == NULL) {
  378. connIter_->set_cur(connIter_->get_last());
  379. next = (*connIter_)();
  380. }
  381. i++;
  382. if (next && next->dynWt_>0) {
  383. next->dynWt_--;
  384. dynWtSum_--;
  385. wtOK = 1;
  386. }
  387. } while (next && (!next->data_left_to_send() || !wtOK)
  388.  && (i < connIter_->count()));
  389. if (!next->data_left_to_send())
  390. next = NULL;
  391. return next;
  392. }
  393. /* coarse-grained interleaving across connections (per block of pkts) */
  394. case COARSE_ROUND_ROBIN: {
  395. int maxConsecSegs;
  396. if (curConn_)
  397. maxConsecSegs = (window()*curConn_->wt_)/wtSum_;
  398. if (curConn_ && numConsecSegs_++ < maxConsecSegs && 
  399. curConn_->data_left_to_send())
  400. return curConn_;
  401. else {
  402. numConsecSegs_ = 0;
  403. curConn_ = who_to_snd(FINE_ROUND_ROBIN);
  404. if (curConn_)
  405. numConsecSegs_++;
  406. }
  407. return curConn_;
  408. }
  409. case RANDOM: {
  410. IntTcpAgent *next;
  412. do {
  413. int foo = int(Random::uniform() * nActive_ + 1);
  415. connIter_->set_cur(connIter_->get_last());
  417. for (;foo > 0; foo--)
  418. (*connIter_)();
  419. next = (*connIter_)();
  420. } while (next && !next->data_left_to_send());
  421. return(next);
  422. }
  423. default:
  424. return NULL;
  425. }
  426. }
  428. void
  429. TcpSessionAgent::send_much(IntTcpAgent* /*agent*/, int force, int reason) 
  430. {
  431. int npackets = 0;
  432. Islist_iter<Segment> seg_iter(seglist_);
  434. if (reason != TCP_REASON_TIMEOUT &&
  435.     burstsnd_timer_.status() == TIMER_PENDING)
  436. return;
  437. /* no outstanding data and idle time >= t_rtxcur_ */
  438. if ((seg_iter.count() == 0) && (last_send_time_ != -1) &&
  439.     (Scheduler::instance().clock() - last_send_time_ >= t_rtxcur_)) {
  440. if (slow_start_restart_ && restart_bugfix_)
  441. slowdown(CLOSE_CWND_INIT);
  442. else if (slow_start_restart_)
  443. slowdown(CLOSE_CWND_RESTART|CLOSE_SSTHRESH_HALF);
  444. else if (fs_enable_) {
  445. if (cwnd_ < ssthresh_)
  446. cwnd_ = int(cwnd_/2);
  447. else
  448. cwnd_ -= 1;
  449. fs_startseq_ = sessionSeqno_ + 1;
  450. fs_endseq_ = sessionSeqno_ + window();
  451. fs_mode_ = 1;
  452. }
  453. }
  455. while (ok_to_snd(size_)) {
  456. {
  457. IntTcpAgent *sender = who_to_snd(schedDisp_);
  458. if (sender) {
  459. /*
  460.  * remember the connection over which the first
  461.  * packet just before fast start is sent
  462.  */
  463. if (fs_enable_ && fs_mode_ && 
  464.     sessionSeqno_ == fs_startseq_)
  465. connWithPktBeforeFS_ = sender;
  466. /* if retransmission */
  467. /* XXX we pick random conn even if rtx timeout */
  468. if (sender->t_seqno_ < sender->maxseq_) {
  469. int i = 
  470. findSessionSeqno(sender, sender->t_seqno_);
  471. removeSessionSeqno(i);
  472. sender->send_one(i);
  473. }
  474. else {
  475. sender->send_one(sessionSeqno_++);
  476. if (!rtt_active_) {
  477. rtt_active_ = 1;
  478. rtt_seg_ = last_seg_sent_;
  479. }
  480. }
  481. npackets++;
  482. }
  483. else
  484. break;
  485. }
  486. reason = 0;
  487. force = 0;
  488. if (maxburst_ && npackets == maxburst_) {
  489. if (ok_to_snd(size_))
  490. burstsnd_timer_.resched(t_exact_srtt_*maxburst_/window());
  491. break;
  492. }
  493. }
  494. if (npackets > 0)
  495. last_send_time_ = Scheduler::instance().clock();
  496. }
  498. void
  499. TcpSessionAgent::recv(IntTcpAgent *agent, Packet *pkt, int amt_data_acked)
  500. {
  501. hdr_tcp *tcph = hdr_tcp::access(pkt);
  503. if (hdr_flags::access(pkt)->ecnecho() && ecn_)
  504. quench(1, agent, tcph->seqno());
  505. clean_segs(size_, pkt, agent, sessionSeqno_,amt_data_acked);
  506. /* XXX okay to do this after clean_segs? */
  507. /* if new data acked and this is not a partial ack */
  508. if (amt_data_acked > 0 && (tcph->seqno() >= agent->recover_ ||
  509.    agent->last_cwnd_action_ != CWND_ACTION_DUPACK /* XXX 1*/) 
  510.     && !dontIncrCwnd_) {
  511. int i = count_bytes_acked_ ? amt_data_acked:1;
  512. while (i-- > 0)
  513. opencwnd(size_,agent);
  514. }
  515. dontIncrCwnd_ = 0;
  516. if (amt_data_acked > 0) {
  517. if (fs_enable_ && fs_mode_ && connWithPktBeforeFS_ == agent)
  518. connWithPktBeforeFS_ = NULL;
  519. newack(pkt);
  520. }
  521. Packet::free(pkt);
  522. send_much(NULL,0,0);
  523. }
  525. void
  526. TcpSessionAgent::setflags(Packet *pkt)
  527. {
  528. hdr_flags *hf = hdr_flags::access(pkt);
  529. if (ecn_)
  530. hf->ect() = 1;
  531. }
  533. int
  534. TcpSessionAgent::findSessionSeqno(IntTcpAgent *sender, int seqno)
  535. {
  536. Islist_iter<Segment> seg_iter(seglist_);
  537. Segment *cur;
  538. int min = sessionSeqno_;
  540. while ((cur = seg_iter()) != NULL) {
  541. if (sender == cur->sender_ && cur->seqno_ >= seqno && 
  542.     cur->sessionSeqno_ < min)
  543. min = cur->sessionSeqno_;
  544. }
  545. if (min == sessionSeqno_) {
  546. printf("In TcpSessionAgent::findSessionSeqno: search unsuccessfuln");
  547. min = sessionSeqno_ - 1;
  548. }
  549. return (min);
  550. }
  553. void
  554. TcpSessionAgent::removeSessionSeqno(int sessionSeqno) 
  555. {
  556. Islist_iter<Segment> seg_iter(seglist_);
  557. Segment *cur, *prev=NULL;
  559. while ((cur = seg_iter()) != NULL) {
  560. if (cur->sessionSeqno_ == sessionSeqno) {
  561. seglist_.remove(cur, prev);
  562. adjust_ownd(cur->size_);
  563. return;
  564. }
  565. prev = cur;
  566. }
  567. printf("In removeSessionSeqno(): unable to find segment with sessionSeqno = %dn", sessionSeqno);
  568. }
  570. void
  571. TcpSessionAgent::quench(int how, IntTcpAgent *sender, int seqno)
  572. {
  573. int i = findSessionSeqno(sender,seqno);
  575. if (i > recover_) {
  576. recover_ = sessionSeqno_ - 1;
  577. last_cwnd_action_ = CWND_ACTION_ECN;
  578. sender->recover_ = sender->maxseq_;
  579. sender->last_cwnd_action_ = CWND_ACTION_ECN;
  580. closecwnd(how,sender);
  581. }
  582. }
  584. void
  585. TcpSessionAgent::traceVar(TracedVar* v)
  586. {
  587. double curtime;
  588. Scheduler& s = Scheduler::instance();
  589. char wrk[500];
  590. int n;
  592. curtime = &s ? s.clock() : 0;
  593. if (!strcmp(v->name(), "ownd_") || !strcmp(v->name(), "owndCorr_")) {
  594. if (!strcmp(v->name(), "ownd_"))
  595. sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f", 
  596. curtime, addr(), port(), daddr(), dport(),
  597. v->name(), double(*((TracedDouble*) v))); 
  598. else if (!strcmp(v->name(), "owndCorr_"))
  599. sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %d", 
  600. curtime, addr(), port(), daddr(), dport(),
  601. v->name(), int(*((TracedInt*) v))); 
  602. n = strlen(wrk);
  603. wrk[n] = 'n';
  604. wrk[n+1] = 0;
  605. if (channel_)
  606. (void)Tcl_Write(channel_, wrk, n+1);
  607. wrk[n] = 0;
  608. }
  609. else
  610. TcpAgent::traceVar(v);
  611. }