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

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

通讯编程

开发平台：

Visual C++

packmime_HTTP.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  3. /* 
  4.  * Copyright 2002, Statistics Research, Bell Labs, Lucent Technologies and
  5.  * The University of North Carolina at Chapel Hill
  6.  * 
  7.  * Redistribution and use in source and binary forms, with or without 
  8.  * modification, are permitted provided that the following conditions are met:
  9.  * 
  10.  *    1. Redistributions of source code must retain the above copyright 
  11.  * notice, this list of conditions and the following disclaimer.
  12.  *    2. Redistributions in binary form must reproduce the above copyright 
  13.  * notice, this list of conditions and the following disclaimer in the 
  14.  * documentation and/or other materials provided with the distribution.
  15.  *    3. The name of the author may not be used to endorse or promote 
  16.  * products derived from this software without specific prior written 
  17.  * permission.
  18.  * 
  19.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 
  20.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
  21.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  22.  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 
  23.  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
  24.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
  25.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
  26.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  27.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
  28.  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
  29.  * POSSIBILITY OF SUCH DAMAGE.
  30.  */
  32. /*
  33.  * Reference
  34.  *     Stochastic Models for Generating Synthetic HTTP Source Traffic 
  35.  *     J. Cao, W.S. Cleveland, Y. Gao, K. Jeffay, F.D. Smith, and M.C. Weigle 
  36.  *     IEEE INFOCOM 2004.
  37.  *
  38.  * Documentation available at http://dirt.cs.unc.edu/packmime/
  39.  * 
  40.  * Contacts: Michele Weigle (mcweigle@cs.unc.edu),
  41.  *           Kevin Jeffay (jeffay@cs.unc.edu)
  42.  */
  44. #include <tclcl.h>
  45. #include "lib/bsd-list.h"
  46. #include "random.h"
  47. #include "tcp-full.h"
  48. #include "packmime_HTTP.h"
  50. #define MbPS2BPS_FACTOR 125000
  52. /*::::::::::::::::::::::::::::::: PACKMIME ::::::::::::::::::::::::::::::::::*/
  54. static class PackMimeHTTPClass : public TclClass {
  55. public:
  56. PackMimeHTTPClass() : TclClass("PackMimeHTTP") {}
  57. TclObject* create(int, const char*const*) {
  58. return (new PackMimeHTTP);
  59. }
  60. } class_packmime;
  62. PackMimeHTTP::PackMimeHTTP() :
  63. TclObject(), timer_(this), connection_interval_(0), 
  64. next_client_ind_(0), next_server_ind_(0), total_nodes_(0),
  65. current_node_(0), outfp_(NULL), fileszfp_(NULL), 
  66. samplesfp_(NULL), rate_(0), segsize_(0), segsperack_(0),
  67. interval_(0), ID_(-1), run_(0), debug_(0), 
  68. cur_pairs_(0), warmup_(0), http_1_1_(false), 
  69. use_pm_persist_rspsz_(true), use_pm_persist_reqsz_(true),
  70. active_connections_(0), total_connections_(-1), running_(0), 
  71. flowarrive_rv_(NULL), reqsize_rv_(NULL), rspsize_rv_(NULL), 
  72. persist_rspsize_rv_(NULL), persistent_rv_(NULL), num_pages_rv_(NULL),
  73. single_obj_rv_(NULL), objs_per_page_rv_(NULL), time_btwn_pages_rv_(NULL),
  74. time_btwn_objs_rv_(NULL), server_delay_rv_(NULL), 
  75. flowarrive_rng_(NULL), reqsize_rng_(NULL), rspsize_rng_(NULL), 
  76. persist_rspsize_rng_(NULL), persistent_rng_(NULL), num_pages_rng_(NULL), 
  77. single_obj_rng_(NULL), objs_per_page_rng_(NULL), time_btwn_pages_rng_(NULL),
  78. time_btwn_objs_rng_(NULL), server_delay_rng_(NULL)
  79. {
  80. int i;
  82. strcpy (tcptype_, "Reno");
  84. for (i=0; i<MAX_NODES; i++) {
  85. server_[i] = NULL;
  86. }
  87. for (i=0; i<MAX_NODES; i++) {
  88. client_[i] = NULL;
  89. }
  90. }
  92. PackMimeHTTP::~PackMimeHTTP()
  93. {
  94. Tcl& tcl = Tcl::instance();
  96. // output stats
  97. if (debug_ > 0) {
  98. fprintf (stderr, "total connections created: %d ", 
  99.  total_connections_+1);
  100. fprintf (stderr, "in pool: %d  active: %dn", 
  101.  (int) serverAppPool_.size(), 
  102.  (int) serverAppActive_.size());
  103. }
  105. // delete timer
  106. timer_.force_cancel();
  108. // delete active clients in the pool
  109. map<string, PackMimeHTTPClientApp*>::iterator ca_iter;
  110. for (ca_iter = clientAppActive_.begin(); 
  111.      ca_iter != clientAppActive_.end(); ca_iter++) {
  112. ca_iter->second->stop();
  113. tcl.evalf ("delete %s", ca_iter->second->name());
  114. clientAppActive_.erase (ca_iter);
  115. }
  117. // delete active servers in the pool
  118. map<string, PackMimeHTTPServerApp*>::iterator sa_iter;
  119. for (sa_iter = serverAppActive_.begin(); 
  120.      sa_iter != serverAppActive_.end(); sa_iter++) {
  121. sa_iter->second->stop();
  122. tcl.evalf ("delete %s", sa_iter->second->name());
  123. serverAppActive_.erase (sa_iter);
  124. }
  126. // delete clients in pool
  127. PackMimeHTTPClientApp* cli;
  128. while (!clientAppPool_.empty()) {
  129. cli = clientAppPool_.front();
  130. cli->stop();
  131. tcl.evalf ("delete %s", cli->name());
  132. clientAppPool_.pop();
  133. }
  135. // delete servers in pool
  136. PackMimeHTTPServerApp* srv;
  137. while (!serverAppPool_.empty()) {
  138. srv = serverAppPool_.front();
  139. srv->stop();
  140. tcl.evalf ("delete %s", srv->name());
  141. serverAppPool_.pop();
  142. }
  144. // delete agents in the pool
  145. FullTcpAgent* tcp;
  146. while (!tcpPool_.empty()) {
  147. tcp = tcpPool_.front();
  148. tcl.evalf ("delete %s", tcp->name());
  149. tcpPool_.pop();
  150. }
  152. // delete RNGs and Random Variables
  153. cleanup();
  155. // close output files
  156. if (outfp_)
  157. fclose(outfp_);
  158.   if (fileszfp_)
  159.   fclose(fileszfp_);
  160.   if (samplesfp_)
  161.   fclose(samplesfp_);
  162. }
  164. FullTcpAgent* PackMimeHTTP::picktcp()
  165. {
  166. FullTcpAgent* a;
  167. Tcl& tcl = Tcl::instance();
  169. if (tcpPool_.empty()) {
  170. tcl.evalf ("%s alloc-tcp %s", name(), tcptype_);
  171. a = (FullTcpAgent*) lookup_obj (tcl.result());
  172. if (a == NULL) {
  173. fprintf (stderr, "Failed to allocate a TCP agentn");
  174. abort();
  175. }
  176. if (debug_ > 1) {
  177. fprintf (stderr, 
  178.  "tflow %d created new TCPAgent %sn",
  179.  total_connections_, a->name());
  180. }
  181. } else {
  182. a = tcpPool_.front();  // grab top of the queue
  183. tcpPool_.pop();         // remove top from queue
  185. if (debug_ > 1) {
  186. fprintf (stderr, "tflow %d got TCPAgent %s", 
  187.  total_connections_, a->name());
  188. fprintf (stderr, " from pool (%d in pool)n",
  189.  (int) tcpPool_.size());
  190. }
  191. }
  193. return a;
  194. }
  196. PackMimeHTTPServerApp* PackMimeHTTP::pickServerApp()
  197. {
  198. PackMimeHTTPServerApp* a;
  200. if (serverAppPool_.empty()) {
  201. Tcl& tcl = Tcl::instance();
  202. tcl.evalf ("%s alloc-server-app", name());
  203. a = (PackMimeHTTPServerApp*) lookup_obj (tcl.result());
  204. if (a == NULL) {
  205. fprintf (stderr, 
  206. "Failed to allocate a PackMimeHTTP server appn");
  207. abort();
  208. }
  209. if (debug_ > 1)
  210. fprintf (stderr, "tflow %d created new ",
  211.  total_connections_);
  212. } else {
  213. a = serverAppPool_.front();   // grab top of the queue
  214. serverAppPool_.pop();         // remove top from queue
  216. if (debug_ > 1)
  217. fprintf (stderr, "tflow %d got ", 
  218.  total_connections_);
  219. }
  221. // initialize server app
  222. a->set_id(total_connections_);
  223. a->set_mgr(this);
  225. if (debug_ > 1)
  226. fprintf (stderr, "ServerApp %s (%d in pool, %d active)n",
  227.  a->name(), (int) serverAppPool_.size(), 
  228.  (int) serverAppActive_.size()+1);
  230. return a;
  231. }
  233. PackMimeHTTPClientApp* PackMimeHTTP::pickClientApp()
  234. {
  235. PackMimeHTTPClientApp* a;
  237. if (clientAppPool_.empty()) {
  238. Tcl& tcl = Tcl::instance();
  239. tcl.evalf ("%s alloc-client-app", name());
  240. a = (PackMimeHTTPClientApp*) lookup_obj (tcl.result());
  241. if (a == NULL) {
  242. fprintf (stderr, 
  243. "Failed to allocate a PackMimeHTTP client appn");
  244. abort();
  245. }
  246. if (debug_ > 1)
  247. fprintf (stderr, "tflow %d created new ",
  248.  total_connections_);
  249. } else {
  250. a = clientAppPool_.front();   // grab top of the queue
  251. clientAppPool_.pop();         // remove top from queue
  253. if (debug_ > 1)
  254. fprintf (stderr, "tflow %d got ", 
  255.  total_connections_);
  256. }
  258. // initialize client app
  259. a->set_id(total_connections_);
  260. a->set_mgr(this);
  262. if (debug_ > 1)
  263. fprintf (stderr, "ClientApp %s (%d in pool, %d active)n",
  264.  a->name(), (int) clientAppPool_.size(), 
  265.  (int) clientAppActive_.size()+1);
  267. return a;
  268. }
  270. void PackMimeHTTP::recycle(FullTcpAgent* agent)
  271. {
  272. /*
  273.  * Problem is that server apps are "done" before client apps,
  274.  * so server agents and apps get recycled and re-used before
  275.  * client apps & agents that were attached to them are
  276.  *
  277.  */
  278. if (agent == NULL) {
  279. fprintf (stderr, "recycle> agent is nulln");
  280. return;
  281. }
  283. // reinitialize FullTcp agent
  284. agent->reset();
  286. // add to the inactive agent pool
  287. tcpPool_.push (agent);
  289. if (debug_ > 2) {
  290. fprintf (stderr, "tTCPAgent %s moved to pool ", 
  291.  agent->name());
  292. fprintf (stderr, "(%d in pool)n", (int) tcpPool_.size());
  293. }
  294. }
  296. void PackMimeHTTP::recycle(PackMimeHTTPClientApp* app)
  297. {
  298. if (app == NULL)
  299. return;
  301. // find the client app in the active pool
  302. map<string, PackMimeHTTPClientApp*>::iterator ca_iter = 
  303. clientAppActive_.find(app->get_agent_name());
  304. if (ca_iter == clientAppActive_.end()) 
  305. return;
  307. // remove the client app from the active pool
  308. clientAppActive_.erase(ca_iter);
  310. // insert the client app into the inactive pool
  311. clientAppPool_.push (app);
  313. if (debug_ > 2) {
  314. fprintf (stderr, "tClientApp %s (%d) moved to pool ", 
  315.  app->name(), app->get_id());
  316. fprintf (stderr, "(%d in pool, %d active)n", 
  317.  (int) clientAppPool_.size(), 
  318.  (int) clientAppActive_.size());
  319. }
  321. // recycle app
  322. app->recycle();
  323. }
  325. void PackMimeHTTP::recycle(PackMimeHTTPServerApp* app)
  326. {
  327. if (app == NULL)
  328. return;
  330. // find the server app in the active pool
  331. map<string, PackMimeHTTPServerApp*>::iterator sa_iter = 
  332. serverAppActive_.find(app->get_agent_name());
  333. if (sa_iter == serverAppActive_.end()) 
  334. return;
  336. // remove the server app from the active pool
  337. serverAppActive_.erase(sa_iter);
  339. // insert the server app into the inactive pool
  340. serverAppPool_.push (app);
  342. if (debug_ > 2) {
  343. fprintf (stderr, "tServerApp %s (%d) moved to pool ",
  344.  app->name(), app->get_id());
  345. fprintf (stderr, "(%d in pool, %d active)n", 
  346.  (int) serverAppPool_.size(), 
  347.  (int) serverAppActive_.size());
  348. }
  350. // recycle app
  351. app->recycle();
  352. }
  354. double PackMimeHTTP::connection_interval() 
  355. {
  356. return connection_interval_;
  357. }
  359. /* HTTP 1.0 functions */
  360. int PackMimeHTTP::get_reqsize() 
  361. {
  362. return (int) (reqsize_rv_->value());
  363. }
  365. int PackMimeHTTP::get_rspsize() 
  366. {
  367. return (int) (rspsize_rv_->value());
  368. }
  370. double PackMimeHTTP::get_server_delay() 
  371. { 
  372. return server_delay_rv_->value();
  373. }
  375. /* HTTP 1.1 functions */
  376. bool PackMimeHTTP::is_persistent()
  377. {
  378. double val = persistent_rv_->value();
  379. if (val == 0) {
  380. return false;
  381. } else {
  382. return true;
  383. }
  384. }
  386. int PackMimeHTTP::get_num_pages()
  387. {
  388. return (int) ceil(num_pages_rv_->value());
  389. }
  391. int PackMimeHTTP::get_num_objs (int pages)
  392. {
  393. int p_singleobj = 0;
  394. int objs = 1;
  396. if (pages > 1) {
  397. // find probabilty there's only one obj in this page
  398. p_singleobj = (int) single_obj_rv_->value();
  399. }
  400. if (p_singleobj == 0) {
  401. objs = (int) ceil(objs_per_page_rv_->value());
  402. if (objs == 1) {
  403. // should be at least 2 objs at this point
  404. objs++;
  405. }
  406. }
  407. return objs;
  408. }
  410. double PackMimeHTTP::get_reqgap (int page, int obj)
  411. {
  412. double val;
  414. if (page == 0 && obj == 0) {
  415. // first request
  416. val = 0;
  417. }
  418. else if (page != 0 && obj == 0) {
  419. // main page (between-page requests)
  420. val = time_btwn_pages_rv_->value();
  421. }
  422. else {
  423. // embedded objects (within-page requests)
  424. val = time_btwn_objs_rv_->value();
  425. }
  426. return val;
  427. }
  429. int PackMimeHTTP::adjust_persist_rspsz()
  430. {
  431. return (int) persist_rspsize_rv_->value();
  432. }
  434. void PackMimeHTTP::reset_persist_rspsz()
  435. {
  436. persist_rspsize_rv_->reset_loc_scale();
  437. }
  439. void PackMimeHTTP::incr_pairs()
  440. /*
  441.  * Keep track of the number of req/rsp pairs 
  442.  */
  443. {
  444. cur_pairs_++;
  445. }
  447. void PackMimeHTTP::setup_connection()
  448. /*
  449.  * Setup a new connection, including creation of Agents and Apps
  450.  */
  451. {
  452. Tcl& tcl = Tcl::instance();
  454. // incr count of connections
  455. active_connections_++;
  456. total_connections_++;
  458. if (debug_ > 1) {
  459. fprintf (stderr, 
  460.  "nPackMimeHTTP %s> new flow %d  total active: %d at %fn",
  461.  name(), total_connections_, active_connections_, now());
  462. }
  464. // pick tcp agent for client and server
  465. FullTcpAgent* ctcp = picktcp();
  466. FullTcpAgent* stcp = picktcp();
  468. // rotate through nodes assigning connections
  469. current_node_++;
  470. if (current_node_ >= total_nodes_)
  471. current_node_ = 0;
  473. // attach agents to nodes (server_ client_)
  474. tcl.evalf ("%s attach %s", server_[current_node_]->name(), 
  475.    stcp->name());
  476. tcl.evalf ("%s attach %s", client_[current_node_]->name(), 
  477.    ctcp->name());
  479. // set TCP options
  480. tcl.evalf ("%s setup-tcp %s %d", name(), stcp->name(), 
  481.    total_connections_);
  482. tcl.evalf ("%s setup-tcp %s %d", name(), ctcp->name(),
  483.    total_connections_);
  485. // setup connection between client and server
  486. tcl.evalf ("set ns [Simulator instance]");
  487. tcl.evalf ("$ns connect %s %s", ctcp->name(), stcp->name());
  488. tcl.evalf ("%s listen", stcp->name());
  490. // create PackMimeHTTPApps
  491. PackMimeHTTPClientApp* client_app = pickClientApp();
  492. PackMimeHTTPServerApp* server_app = pickServerApp();
  494. // attach TCPs to PackMimeHTTPApps
  495. ctcp->attachApp ((Application*) client_app);
  496. stcp->attachApp ((Application*) server_app);
  497. client_app->set_server(server_app);
  498. client_app->set_agent(ctcp);
  499. server_app->set_agent(stcp);
  501. // put apps in active list
  502. clientAppActive_[ctcp->name()] = client_app;
  503. serverAppActive_[stcp->name()] = server_app;
  505. // start PackMimeHTTPApps
  506. client_app->start();
  507. server_app->start();
  509. // set time for next connection to start
  510. connection_interval_ = flowarrive_rv_->value();
  511. }
  513. void PackMimeHTTP::start()
  514. {            
  515. int i;
  517. // make sure that we have the same number of server nodes
  518. // and client nodes
  519. if (next_client_ind_ != next_server_ind_) {
  520. fprintf (stderr, "Error: %d clients and %d servers", 
  521.  next_client_ind_, next_server_ind_);
  522. exit(-1);
  523. }
  524. total_nodes_ = next_client_ind_;
  526. running_ = 1;
  528. // initialize PackMimeHTTP random variables
  529. if (flowarrive_rv_ == NULL) {
  530. flowarrive_rng_ = (RNG*) new RNG();
  531. // select proper substream
  532. for (i=0; i<run_; i++) {
  533. flowarrive_rng_->reset_next_substream();
  534. }
  535. flowarrive_rv_ = (PackMimeHTTPFlowArriveRandomVariable*) new
  536. PackMimeHTTPFlowArriveRandomVariable (rate_,
  537.       flowarrive_rng_);
  538. if (debug_ > 1) {
  539. fprintf (stderr, "Created FlowArrive RNG and RVn");
  540. }
  541. }
  542. if (reqsize_rv_ == NULL) {
  543. reqsize_rng_ = (RNG*) new RNG();
  544. // select proper substream
  545. for (i=0; i<run_; i++) {
  546. reqsize_rng_->reset_next_substream();
  547. }
  548. reqsize_rv_ = (PackMimeHTTPFileSizeRandomVariable*) new
  549. PackMimeHTTPFileSizeRandomVariable (rate_, 
  550. PACKMIME_REQ_SIZE,
  551.     reqsize_rng_);
  552. if (debug_ > 1) {
  553. fprintf (stderr, "Created ReqSize RNG and RVn");
  554. }
  555. }
  556. if (rspsize_rv_ == NULL) {
  557. rspsize_rng_ = (RNG*) new RNG();
  558. // select proper substream
  559. for (i=0; i<run_; i++) {
  560. rspsize_rng_->reset_next_substream();
  561. }
  562. rspsize_rv_ = (PackMimeHTTPFileSizeRandomVariable*) new
  563. PackMimeHTTPFileSizeRandomVariable (rate_, 
  564. PACKMIME_RSP_SIZE,
  565.     rspsize_rng_);
  566. if (debug_ > 1) {
  567. fprintf (stderr, "Created RspSize RNG and RVn");
  568. }
  569. }
  570. if (server_delay_rv_ == NULL) {
  571. server_delay_rng_ = (RNG*) new RNG();
  572. // select proper substream
  573. for (i=0; i<run_; i++) {
  574. server_delay_rng_->reset_next_substream();
  575. }
  576. server_delay_rv_ = (PackMimeHTTPServerDelayRandomVariable*) new 
  577. PackMimeHTTPServerDelayRandomVariable 
  578. (PackMimeHTTPServerDelayRandomVariable::SERVER_DELAY_SHAPE, 
  579.  PackMimeHTTPServerDelayRandomVariable::SERVER_DELAY_SCALE, 
  580.  server_delay_rng_);
  581. if (debug_ > 1) {
  582. fprintf (stderr, "Created ServerDelay RNG and RVn");
  583. }
  584. }
  585. if (persist_rspsize_rv_ == NULL) {
  586. persist_rspsize_rng_ = (RNG*) new RNG();
  587. // select proper substream
  588. for (i=0; i<run_; i++) {
  589. persist_rspsize_rng_->reset_next_substream();
  590. }
  591. persist_rspsize_rv_ = (PackMimeHTTPPersistRspSizeRandomVariable*) new 
  592. PackMimeHTTPPersistRspSizeRandomVariable(persist_rspsize_rng_);
  593. if (debug_ > 1) {
  594. fprintf (stderr, "Created Persistent RspSz RNG and RVn");
  595. }
  596. }
  597. if (persistent_rv_ == NULL) {
  598. persistent_rng_ = (RNG*) new RNG();
  599. // select proper substream
  600. for (i=0; i<run_; i++) {
  601. persistent_rng_->reset_next_substream();
  602. }
  603. persistent_rv_ = (PackMimeHTTPPersistentRandomVariable*) new 
  604. PackMimeHTTPPersistentRandomVariable
  605. (PackMimeHTTPPersistentRandomVariable::P_PERSISTENT,
  606.  persistent_rng_);
  607. if (debug_ > 1) {
  608. fprintf (stderr, "Created Persistent RNG and RVn");
  609. }
  610. }
  611. if (num_pages_rv_ == NULL) {
  612. num_pages_rng_ = (RNG*) new RNG();
  613. // select proper substream
  614. for (i=0; i<run_; i++) {
  615. num_pages_rng_->reset_next_substream();
  616. }
  617. num_pages_rv_ = (PackMimeHTTPNumPagesRandomVariable*) new 
  618. PackMimeHTTPNumPagesRandomVariable
  619. (PackMimeHTTPNumPagesRandomVariable::P_1PAGE,
  620.  PackMimeHTTPNumPagesRandomVariable::SHAPE_NPAGE,
  621.  PackMimeHTTPNumPagesRandomVariable::SCALE_NPAGE,
  622.  num_pages_rng_);
  623. if (debug_ > 1) {
  624. fprintf (stderr, "Created Number of Pages RNG and RVn");
  625. }
  626. }
  627. if (single_obj_rv_ == NULL) {
  628. single_obj_rng_ = (RNG*) new RNG();
  629. // select proper substream
  630. for (i=0; i<run_; i++) {
  631. single_obj_rng_->reset_next_substream();
  632. }
  633. single_obj_rv_ = (PackMimeHTTPSingleObjRandomVariable*) new 
  634. PackMimeHTTPSingleObjRandomVariable
  635. (PackMimeHTTPSingleObjRandomVariable::P_1TRANSFER,
  636.  single_obj_rng_);
  637. if (debug_ > 1) {
  638. fprintf (stderr, "Created Single Objects RNG and RVn");
  639. }
  640. }
  641. if (objs_per_page_rv_ == NULL) {
  642. objs_per_page_rng_ = (RNG*) new RNG();
  643. // select proper substream
  644. for (i=0; i<run_; i++) {
  645. objs_per_page_rng_->reset_next_substream();
  646. }
  647. objs_per_page_rv_ = (PackMimeHTTPObjsPerPageRandomVariable*) new 
  648. PackMimeHTTPObjsPerPageRandomVariable
  649. (PackMimeHTTPObjsPerPageRandomVariable::SHAPE_NTRANSFER,
  650.  PackMimeHTTPObjsPerPageRandomVariable::SCALE_NTRANSFER,
  651.  objs_per_page_rng_);
  652. if (debug_ > 1) {
  653. fprintf (stderr, "Created Objects Per Page RNG and RVn");
  654. }
  655. }
  656. if (time_btwn_pages_rv_ == NULL) {
  657. time_btwn_pages_rng_ = (RNG*) new RNG();
  658. // select proper substream
  659. for (i=0; i<run_; i++) {
  660. time_btwn_pages_rng_->reset_next_substream();
  661. }
  662. time_btwn_pages_rv_ = (PackMimeHTTPTimeBtwnPagesRandomVariable*) new 
  663. PackMimeHTTPTimeBtwnPagesRandomVariable(time_btwn_pages_rng_);
  664. if (debug_ > 1) {
  665. fprintf (stderr, "Created Time Btwn Pages RNG and RVn");
  666. }
  667. }
  668. if (time_btwn_objs_rv_ == NULL) {
  669. time_btwn_objs_rng_ = (RNG*) new RNG();
  670. // select proper substream
  671. for (i=0; i<run_; i++) {
  672. time_btwn_objs_rng_->reset_next_substream();
  673. }
  674. time_btwn_objs_rv_ = (PackMimeHTTPTimeBtwnObjsRandomVariable*) new 
  675. PackMimeHTTPTimeBtwnObjsRandomVariable(time_btwn_objs_rng_);
  676. if (debug_ > 1) {
  677. fprintf (stderr, "Created Time Btwn Objs RNG and RVn");
  678. }
  679. }
  681. // schedule first connection
  682. timer_.sched (0);
  683. }
  685. void PackMimeHTTP::stop()
  686. {
  687. running_ = 0;
  688. }
  690. void PackMimeHTTP::cleanup()
  691. {
  692. // delete all 'new'ed variables
  693. if (reqsize_rv_ != NULL) {
  694. delete reqsize_rv_;
  695. }
  696. if (rspsize_rv_ != NULL) {
  697. delete rspsize_rv_;
  698. }
  699. if (persist_rspsize_rv_ != NULL) {
  700. delete persist_rspsize_rv_;
  701. }
  702. if (flowarrive_rv_ != NULL) {
  703. delete flowarrive_rv_;
  704. }
  705. if (server_delay_rv_ != NULL) {
  706. delete server_delay_rv_;
  707. }
  708. if (persistent_rv_ != NULL) {
  709. delete persistent_rv_;
  710. }
  711. if (num_pages_rv_ != NULL) {
  712. delete num_pages_rv_;
  713. }
  714. if (single_obj_rv_ != NULL) {
  715. delete single_obj_rv_;
  716. }
  717. if (objs_per_page_rv_ != NULL) {
  718. delete objs_per_page_rv_;
  719. }
  720. if (time_btwn_pages_rv_ != NULL) {
  721. delete time_btwn_pages_rv_;
  722. }
  723. if (time_btwn_objs_rv_ != NULL) {
  724. delete time_btwn_objs_rv_;
  725. }
  726. if (flowarrive_rng_ != NULL) {
  727. delete flowarrive_rng_;
  728. }
  729. if (reqsize_rng_ != NULL) {
  730. delete reqsize_rng_;
  731. }
  732. if (rspsize_rng_ != NULL) {
  733. delete rspsize_rng_;
  734. }
  735. if (server_delay_rng_ != NULL) {
  736. delete server_delay_rng_;
  737. }
  738. if (persistent_rng_ != NULL) {
  739. delete persistent_rng_;
  740. }
  741. if (num_pages_rng_ != NULL) {
  742. delete num_pages_rng_;
  743. }
  744. if (single_obj_rng_ != NULL) {
  745. delete single_obj_rng_;
  746. }
  747. if (objs_per_page_rng_ != NULL) {
  748. delete objs_per_page_rng_;
  749. }
  750. if (time_btwn_pages_rng_ != NULL) {
  751. delete time_btwn_pages_rng_;
  752. }
  753. if (time_btwn_objs_rng_ != NULL) {
  754. delete time_btwn_objs_rng_;
  755. }
  756. }
  758. int PackMimeHTTP::command(int argc, const char*const* argv) {
  759. if (argc == 2) {
  760. if (!strcmp (argv[1], "start")) {
  761. start();
  762. return (TCL_OK);
  763. }
  764. else if (!strcmp (argv[1], "stop")) {
  765. stop();
  766. return (TCL_OK);
  767. }
  768. else if ((!strcmp (argv[1], "set-1.1")) ||
  769.  (!strcmp (argv[1], "set-http-1.1"))) {
  770. http_1_1_ = true;
  771. return (TCL_OK);
  772. }
  773. else if (!strcmp (argv[1], "active-connections")) {
  774. if (outfp_) {
  775. fprintf (outfp_, "%d ", active_connections_);
  776. fflush (outfp_);
  777. }
  778. else
  779. fprintf (stderr, "%d ", active_connections_);
  780. return (TCL_OK);
  781. }
  782. else if (!strcmp (argv[1], "total-connections")) {
  783. fprintf (stderr, "%d ", total_connections_);
  784. return (TCL_OK);
  785. }
  786. else if (strcmp (argv[1], "get-pairs") == 0) {
  787. Tcl &tcl = Tcl::instance();
  788. tcl.resultf("%d", cur_pairs_);
  789. return (TCL_OK);
  790. }
  791. else if (!strcmp (argv[1], "no-pm-persistent-reqsz")) {
  792. use_pm_persist_reqsz_ = false;
  793. return (TCL_OK);
  794. }
  795. else if (!strcmp (argv[1], "no-pm-persistent-rspsz")) {
  796. use_pm_persist_rspsz_ = false;
  797. return (TCL_OK);
  798. }
  799. }
  800. else if (argc == 3) {
  801. if ((!strcmp (argv[1], "set-client")) 
  802.     || (!strcmp (argv[1], "client"))) {
  803. if (next_client_ind_ >= MAX_NODES) {
  804. return (TCL_ERROR);
  805. }
  806. client_[next_client_ind_] = (Node*) 
  807. lookup_obj(argv[2]);
  808. if (client_[next_client_ind_] == NULL) {
  809. return (TCL_ERROR);
  810. }
  811. next_client_ind_++;
  812. return (TCL_OK);
  813. }
  814. else if ((!strcmp (argv[1], "set-server")) || 
  815.  (!strcmp (argv[1], "server"))) {
  816. if (next_server_ind_ >= MAX_NODES) {
  817. return (TCL_ERROR);
  818. }
  819. server_[next_server_ind_] = (Node*) 
  820. lookup_obj(argv[2]);
  821. if (server_[next_server_ind_] == NULL)
  822. return (TCL_ERROR);
  823. next_server_ind_++;
  824. return (TCL_OK);
  825. }
  826. else if (!strcmp (argv[1], "set-TCP")) {
  827. strcpy (tcptype_, argv[2]);
  828. return (TCL_OK);
  829. }
  830. else if ((!strcmp (argv[1], "set-rate")) ||
  831.  (!strcmp (argv[1], "rate"))) {
  832. rate_ = (double) atof (argv[2]);
  833. return (TCL_OK);
  834. }
  835. else if (!strcmp (argv[1], "set-outfile")) {
  836. outfp_ = fopen (argv[2], "w");
  837. if (outfp_)
  838. return (TCL_OK);
  839. else 
  840. return (TCL_ERROR);
  841. }
  842. else if (!strcmp (argv[1], "set-filesz-outfile")) {
  843.   fileszfp_ = fopen (argv[2], "w");
  844.   if (fileszfp_) 
  845.   return (TCL_OK);
  846.   else 
  847.   return (TCL_ERROR);
  848.   }
  849.   else if (!strcmp (argv[1], "set-samples-outfile")) {
  850.   samplesfp_ = fopen (argv[2], "w");
  851.   if (samplesfp_) 
  852.   return (TCL_OK);
  853.   else 
  854.   return (TCL_ERROR);
  855.   }
  856. else if (strcmp (argv[1], "set-req_size") == 0) {
  857. int res = lookup_rv (reqsize_rv_, argv[2]);
  858. if (res == TCL_ERROR) {
  859. fprintf (stderr, "Invalid req size ");
  860. fprintf (stderr, "random variablen");
  861. cleanup();
  862. return (TCL_ERROR);
  863. }
  864. return (TCL_OK);
  865. }
  866. else if (strcmp (argv[1], "set-rsp_size") == 0) {
  867. int res = lookup_rv (rspsize_rv_, argv[2]);
  868. if (res == TCL_ERROR) {
  869. fprintf (stderr, "Invalid rsp size ");
  870. fprintf (stderr, "random variablen");
  871. cleanup();
  872. return (TCL_ERROR);
  873. }
  874. return (TCL_OK);
  875. }
  876. else if (strcmp (argv[1], "set-flow_arrive") == 0) {
  877. int res = lookup_rv (flowarrive_rv_, argv[2]);
  878. if (res == TCL_ERROR) {
  879. fprintf (stderr,"Invalid flow arrive ");
  880. fprintf (stderr, "random variablen");
  881. cleanup();
  882. return (TCL_ERROR);
  883. }
  884. return (TCL_OK);
  885. }
  886. else if (strcmp (argv[1], "set-server_delay") == 0) {
  887. int res = lookup_rv (server_delay_rv_, argv[2]);
  888. if (res == TCL_ERROR) {
  889. fprintf (stderr,"Invalid server delay ");
  890. fprintf (stderr, "random variablen");
  891. cleanup();
  892. return (TCL_ERROR);
  893. }
  894. return (TCL_OK);
  895. }
  896. else if (!strcmp (argv[1], "set-prob_persistent")) {
  897. int res = lookup_rv (persistent_rv_, argv[2]);
  898. if (res == TCL_ERROR) {
  899. fprintf (stderr,"Invalid percent persistent ");
  900. fprintf (stderr, "random variablen");
  901. cleanup();
  902. return (TCL_ERROR);
  903. }
  904. return (TCL_OK);
  905. }
  906. else if (!strcmp (argv[1], "set-num_pages")) {
  907. int res = lookup_rv (num_pages_rv_, argv[2]);
  908. if (res == TCL_ERROR) {
  909. fprintf (stderr,"Invalid number of pages ");
  910. fprintf (stderr, "random variablen");
  911. cleanup();
  912. return (TCL_ERROR);
  913. }
  914. return (TCL_OK);
  915. }
  916. else if (!strcmp (argv[1], "set-prob_single_obj")) {
  917. int res = lookup_rv (single_obj_rv_, argv[2]);
  918. if (res == TCL_ERROR) {
  919. fprintf (stderr,"Invalid probability single obj ");
  920. fprintf (stderr, "random variablen");
  921. cleanup();
  922. return (TCL_ERROR);
  923. }
  924. return (TCL_OK);
  925. }
  926. else if (!strcmp (argv[1], "set-objs_per_page")) {
  927. int res = lookup_rv (objs_per_page_rv_, argv[2]);
  928. if (res == TCL_ERROR) {
  929. fprintf (stderr,"Invalid objects per page ");
  930. fprintf (stderr, "random variablen");
  931. cleanup();
  932. return (TCL_ERROR);
  933. }
  934. return (TCL_OK);
  935. }
  936. else if (!strcmp (argv[1], "set-time_btwn_pages")) {
  937. int res = lookup_rv (time_btwn_pages_rv_, argv[2]);
  938. if (res == TCL_ERROR) {
  939. fprintf (stderr,"Invalid time between pages ");
  940. fprintf (stderr, "random variablen");
  941. cleanup();
  942. return (TCL_ERROR);
  943. }
  944. return (TCL_OK);
  945. }
  946. else if (!strcmp (argv[1], "set-time_btwn_objs")) {
  947. int res = lookup_rv (time_btwn_objs_rv_, argv[2]);
  948. if (res == TCL_ERROR) {
  949. fprintf (stderr,"Invalid time between objs ");
  950. fprintf (stderr, "random variablen");
  951. cleanup();
  952. return (TCL_ERROR);
  953. }
  954. return (TCL_OK);
  955. }
  956. else if (strcmp (argv[1], "set-ID") == 0) {
  957. ID_ = (int) atoi (argv[2]);
  958. return (TCL_OK);
  959. }
  960. else if (strcmp (argv[1], "set-run") == 0) {
  961. run_ = (int) atoi (argv[2]);
  962. return (TCL_OK);
  963. }
  964. else if (strcmp (argv[1], "set-debug") == 0) {
  965. debug_ = (int) atoi (argv[2]);
  966. return (TCL_OK);
  967. }
  968. else if (strcmp (argv[1], "set-warmup") == 0) {
  969. warmup_ = (int) atoi (argv[2]);
  970. return (TCL_OK);
  971. }
  972. else if (strcmp (argv[1], "recycle") == 0) {
  973. FullTcpAgent* tcp = (FullTcpAgent*) 
  974. lookup_obj(argv[2]);
  976. /*
  977.  * Need to wait to recycle server until client
  978.  * is done.  Fortunately, client has
  979.  * a handle to the server.
  980.  */
  982. // find client app associated with this agent
  983. map<string, PackMimeHTTPClientApp*>::iterator ca_iter = 
  984. clientAppActive_.find(tcp->name());
  985. if (ca_iter == clientAppActive_.end()) {
  986. // this isn't a client app, but a server app
  987. return (TCL_OK);
  988. }
  990. PackMimeHTTPClientApp* ca = ca_iter->second;
  991. PackMimeHTTPServerApp* sa = ca->get_server();
  992. FullTcpAgent* stcp = (FullTcpAgent*) 
  993. lookup_obj(sa->get_agent_name());
  995. if (debug_ > 1)
  996.       fprintf (stderr, "client %s (%d)> DONE at %fn",
  997.  ca->name(), ca->get_id(), now());
  999. // remove apps from active pools and put 
  1000. // in inactive pools
  1001. recycle ((FullTcpAgent*) tcp);
  1002. recycle ((FullTcpAgent*) stcp);
  1003. recycle (ca);
  1004. recycle (sa);
  1006. active_connections_--;   // one less active conn
  1007. return (TCL_OK);
  1008. }
  1009. }
  1010. return TclObject::command(argc, argv);
  1011. }
  1014. /*:::::::::::::::::::::::::::: PACKMIMETIMER ::::::::::::::::::::::::::::::::*/
  1016. void PackMimeHTTPTimer::expire(Event* = 0) 
  1017. {
  1019. }
  1021. void PackMimeHTTPTimer::handle(Event* e)
  1022. {
  1023. if (!mgr_->running()) {
  1024. if (mgr_->get_active() != 0) {
  1025. TimerHandler::handle(e);
  1026. sched (1);              // check back in 1 second...
  1027. }
  1028. return;
  1029. }
  1031. // setup new connection
  1032. mgr_->setup_connection();
  1034. TimerHandler::handle(e);
  1036. // schedule time for next connection
  1037. if (mgr_->debug() > 1) {
  1038. fprintf (stderr, "tnext connection scheduled in %f s...n", 
  1039.  mgr_->connection_interval());
  1040. }
  1041. sched (mgr_->connection_interval());
  1042. }
  1045. /*:::::::::::::::::::::::::: PACKMIMECLIENTAPP ::::::::::::::::::::::::::::::*/
  1047. void PackMimeHTTPClientAppTimer::expire(Event* = 0)
  1048. {
  1049. }
  1051. void PackMimeHTTPClientAppTimer::handle(Event* e)
  1052. {
  1053. t_->timeout();
  1054. TimerHandler::handle(e);
  1055. }
  1057. static class PackMimeHTTPClientAppClass : public TclClass {
  1058. public:
  1059. PackMimeHTTPClientAppClass() : TclClass("Application/PackMimeHTTP/Client") {}
  1060. TclObject* create(int, const char*const*) {
  1061. return (new PackMimeHTTPClientApp);
  1062. }
  1063. } class_app_packmime_client;
  1065. PackMimeHTTPClientApp::~PackMimeHTTPClientApp()
  1066. {
  1067. Tcl& tcl = Tcl::instance();
  1068. if (agent_ != NULL) {
  1069. tcl.evalf ("delete %s", agent_->name());
  1070. }
  1071. if (reqsize_array_ != NULL) {
  1072. delete []reqsize_array_;
  1073. }
  1074. if (rspsize_array_ != NULL) {
  1075. delete []rspsize_array_;
  1076. }
  1077. if (reqgap_array_ != NULL) {
  1078. delete []reqgap_array_;
  1079. }
  1080. }
  1082. void PackMimeHTTPClientApp::start()
  1083. {
  1084. running_ = 1;
  1085. timer_.sched(0);   // send data now
  1086. }
  1088. void PackMimeHTTPClientApp::stop()
  1089. {
  1090. running_ = 0;
  1091. }
  1093. void PackMimeHTTPClientApp::recycle()
  1094. {
  1095. id_ = 0;
  1096. rspsize_ = 0;
  1097. totalbytes_ = 0;
  1098. agent_ = NULL;
  1099. server_ = NULL;
  1100. reqs_ = 0;
  1101. array_ind_ = 0;
  1102. if (reqsize_array_ != NULL) {
  1103. delete []reqsize_array_;
  1104. }
  1105. if (rspsize_array_ != NULL) {
  1106. delete []rspsize_array_;
  1107. }
  1108. if (reqgap_array_ != NULL) {
  1109. delete []reqgap_array_;
  1110. }
  1111. reqsize_array_ = NULL;
  1112. rspsize_array_ = NULL;
  1113. reqgap_array_ = NULL;
  1114. }
  1116. void PackMimeHTTPClientApp::timeout()
  1117. {
  1118. /* Time to generate a new request */
  1120. int i, j, pages, objs, ind;
  1121. int* objs_per_page;
  1122. int reqsz, rspsz;
  1124. if (!running_) {
  1125. return;
  1126. }
  1128. /*
  1129.  * Client should get reqsize and rspsize so that for the same
  1130.  * seed, there will be the same request/response pairs.
  1131.  */
  1133. if (mgr_->using_http_1_1() && reqs_ == 0) {
  1134. // determine if this connection is persistent
  1135. persistent_ = mgr_->is_persistent();
  1136. }
  1138. if (persistent_ && reqs_ == 0) {
  1139. // need to sample the request gaps and file sizes
  1141. // get number of pages in this connection
  1142. pages = mgr_->get_num_pages();
  1143. objs_per_page = new int[pages];
  1144. for (i=0; i<pages; i++) {
  1145. // get number of objects on this page
  1146. objs = mgr_->get_num_objs(pages);
  1147. objs_per_page[i] = objs;
  1148. reqs_ += objs;
  1149. }
  1151. // allocate space for request gaps and file sizes
  1152. if (reqgap_array_ == NULL) {
  1153. reqgap_array_ = new double[reqs_];
  1154. }
  1155. if (reqsize_array_ == NULL) {
  1156. reqsize_array_ = new int[reqs_];
  1157. }
  1158. if (rspsize_array_ == NULL) {
  1159. rspsize_array_ = new int[reqs_];
  1160. }
  1162. // fill the arrays
  1163. ind = 0;
  1164. reqsz = mgr_->get_reqsize();
  1165. rspsz = mgr_->get_rspsize();
  1166. for (i=0; i<pages; i++) {
  1167. for (j=0; j<objs_per_page[i]; j++) {
  1168. // sample inter-request time
  1169. reqgap_array_[ind] = mgr_->get_reqgap(i,j);
  1170. // all requests are same size
  1171. reqsize_array_[ind] = reqsz;
  1172. if (!mgr_->use_pm_persist_reqsz() && ind > 0) {
  1173. reqsize_array_[ind] = mgr_->get_reqsize();
  1174. }
  1175. // all responses start out as same size
  1176. rspsize_array_[ind] = rspsz;
  1177. // for non-PM rspsz, choose new response size
  1178. if (!mgr_->use_pm_persist_rspsz() && ind > 0) {
  1179. rspsize_array_[ind] = mgr_->get_rspsize();
  1180. }
  1181. ind++;
  1182. }
  1183. }
  1185. if (mgr_->use_pm_persist_rspsz()) {
  1186. // adjust response sizes
  1187. if (reqs_ > 1 && 
  1188.     rspsz > 
  1189.     PackMimeHTTPPersistRspSizeRandomVariable::FSIZE_CACHE_CUTOFF) {
  1190. for (i=1; i<reqs_; i++) {
  1191. // leave rspsize_array_[0] alone
  1192. rspsize_array_[i] = 
  1193. mgr_->adjust_persist_rspsz();
  1194. }
  1195. }
  1196. mgr_->reset_persist_rspsz();
  1197. }
  1199. array_ind_ = 0;
  1200. delete [] objs_per_page;
  1201. }
  1203. if (persistent_) {
  1204. // get the current request size
  1205. reqsize_ = reqsize_array_[array_ind_];
  1206. // get the current response size
  1207. rspsize_ = rspsize_array_[array_ind_++];
  1208. }
  1209. else {
  1210. reqs_ = 1;
  1212. // get request size
  1213. reqsize_ = mgr_->get_reqsize();
  1214. // get response size
  1215. rspsize_ = mgr_->get_rspsize();
  1216. }
  1218. // check for 0-byte request or response
  1219. if (reqsize_ == 0) 
  1220. reqsize_ = 1;
  1221. if (rspsize_ == 0) 
  1222. rspsize_ = 1;
  1224. server_->set_reqs(reqs_);
  1225. if (reqs_ == 1 || array_ind_ == reqs_) {
  1226. server_->set_last_req();
  1227. }
  1228. server_->set_reqsize(reqsize_);
  1229. server_->set_rspsize(rspsize_);
  1231. // save time of request
  1232. time_of_req_ = mgr_->now();
  1234. // dump request size and response size
  1235.   FILE* fp = mgr_->get_samplesfp();
  1236.   if (fp) {
  1237.   char* nodeaddr = 
  1238.   Address::instance().print_nodeaddr(agent_->daddr());
  1239.   char* portaddr = 
  1240.   Address::instance().print_nodeaddr(agent_->dport());
  1241.   fprintf (fp, "%-11.6f %-10d %-10d %s.%-6sn",
  1242.    time_of_req_, reqsize_, rspsize_, nodeaddr, portaddr);
  1243.   fflush (fp);
  1244.   }
  1246. // send request
  1247. agent_->sendmsg(reqsize_);
  1248. if (mgr_->debug() > 1)
  1249. fprintf (stderr, "client %s (%d)> sent %d-byte req (%d-byte rsp) at %fn",
  1250.  name(), id_, reqsize_, rspsize_, time_of_req_);
  1251. }
  1253. void PackMimeHTTPClientApp::recv(int bytes)
  1254. {
  1255. // we've received a packet
  1256. if (mgr_->debug() > 3)
  1257. fprintf (stderr, "client %s (%d)> received %d bytes at %fn", 
  1258.  name(), id_, bytes, mgr_->now());
  1260. totalbytes_ += bytes;
  1262. if (totalbytes_ == rspsize_) {
  1263. // we've received all packets from server
  1264. if (mgr_->debug() > 1) {
  1265. fprintf (stderr, "client %s (%d)> received ",
  1266.  name(), id_);
  1267. fprintf (stderr, "total of %d bytes at %fn", 
  1268.  rspsize_, mgr_->now());
  1269. }
  1271. if (reqs_ == 1 || array_ind_ == reqs_) {
  1272. // either only 1 request or we've sent all requests
  1273. stop();
  1274. }
  1275. else {
  1276. // schedule next request time
  1277. timer_.sched(reqgap_array_[array_ind_]);
  1278. }
  1280. if (time_of_req_ >= mgr_->get_warmup()) {
  1281. // if we're dumping output, dump now
  1282. double now = mgr_->now();
  1283. FILE* fp = mgr_->get_outfp();
  1284. char* dst_nodeaddr = 
  1285.     Address::instance().print_nodeaddr(agent_->daddr());
  1286. char* dst_portaddr = 
  1287.     Address::instance().print_nodeaddr(agent_->dport());
  1288. if (fp) {
  1289. fprintf (fp, "%-11.6f %-10d %-10d %-10.3f %s.%-6s %-7dn",
  1290.  now, reqsize_, rspsize_, 
  1291.  (now - time_of_req_) * 1000.0, 
  1292.  dst_nodeaddr, dst_portaddr,
  1293.  mgr_->get_active());
  1294. fflush (fp);
  1295. }
  1296. }
  1298. // increment number of pairs completed
  1299. mgr_->incr_pairs();
  1301. // reset totalbytes
  1302. totalbytes_ = 0;
  1303. }
  1304. }
  1307. /*:::::::::::::::::::::::::: PACKMIMESERVERAPP ::::::::::::::::::::::::::::::*/
  1309. void PackMimeHTTPServerAppTimer::expire(Event* = 0)
  1310. {
  1311. }
  1313. void PackMimeHTTPServerAppTimer::handle(Event* e)
  1314. {
  1315. t_->timeout();
  1316. TimerHandler::handle(e);
  1317. }
  1319. static class PackMimeHTTPServerAppClass : public TclClass {
  1320. public:
  1321. PackMimeHTTPServerAppClass() : TclClass("Application/PackMimeHTTP/Server") {}
  1322. TclObject* create(int, const char*const*) {
  1323. return (new PackMimeHTTPServerApp);
  1324. }
  1325. } class_app_packmime_server;
  1327. PackMimeHTTPServerApp::~PackMimeHTTPServerApp()
  1328. {
  1329. Tcl& tcl = Tcl::instance();
  1330. if (agent_ != NULL) {
  1331. tcl.evalf ("delete %s", agent_->name());
  1332. }
  1333. }
  1335. void PackMimeHTTPServerApp::timeout()
  1336. {
  1337. if (!running_) {
  1338. return;
  1339. }
  1341. if (mgr_->debug() > 1) {
  1342. fprintf(stderr,"server %s (%d)> sent %d-byte response at %fn",
  1343. name(), id_, rspsize_, mgr_->now());
  1344. }
  1346. // dump all request size and response sizes
  1347.   double now = mgr_->now();
  1348.   FILE* fp = mgr_->get_fileszfp();
  1349.   if (fp) {
  1350.   char* nodeaddr = 
  1351.   Address::instance().print_nodeaddr(agent_->addr());
  1352.   char* portaddr = 
  1353.   Address::instance().print_nodeaddr(agent_->port());
  1354. fprintf (fp, "%-11.6f %-10d %-10d %s.%-6sn",
  1355.    now, reqsize_, rspsize_, nodeaddr, portaddr);
  1356.   fflush (fp);
  1357.   }
  1359. // send response
  1360. if (reqs_ == 1 || lastreq_) {
  1361. // this is the last message
  1362. agent_->sendmsg(rspsize_, "MSG_EOF");
  1363. stop();
  1364. }
  1365. else {
  1366. agent_->sendmsg(rspsize_);
  1367. }
  1368. }
  1370. void PackMimeHTTPServerApp::stop()
  1371. {
  1372. running_ = 0;
  1373. }
  1375. void PackMimeHTTPServerApp::recycle()
  1376. {
  1377. id_ = 0;
  1378. reqsize_ = 0;
  1379. rspsize_ = 0;
  1380. totalbytes_ = 0;
  1381. agent_ = NULL;
  1382. reqs_ = 0;
  1383. lastreq_ = false;
  1384. }
  1387. void PackMimeHTTPServerApp::recv(int bytes)
  1388. {
  1389. double delay;
  1391. if (!running_) {
  1392. return;
  1393. }
  1395. totalbytes_ += bytes;
  1397. // we've received a packet
  1398. if (mgr_->debug() > 3)
  1399. fprintf (stderr, "server %s (%d)> received %d bytes at %fn", 
  1400.  name(), id_, bytes, mgr_->now());
  1402. if (totalbytes_ == reqsize_) {
  1403. // generate waiting time
  1404. delay = mgr_->get_server_delay();
  1405. if (mgr_->debug() > 1) {
  1406. fprintf (stderr, 
  1407.  "server %s (%d)> received total of %d bytes from clientn",
  1408.  name(), id_, reqsize_);
  1409. fprintf (stderr, 
  1410.  "server %s (%d)> waiting %f s before responding at %fn", 
  1411.  name(), id_, delay, mgr_->now());
  1412. }
  1414. // send data after waiting server delay seconds
  1415. timer_.sched(delay);   
  1417. // reset totalbytes_
  1418. totalbytes_ = 0;
  1419. }
  1420. }