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

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

通讯编程

开发平台：

Visual C++

packmime_ranvar.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 <stdio.h>
  45. #include <stdlib.h>
  46. #include <assert.h>
  47. #include <math.h>
  48. #include "packmime_ranvar.h"
  50. /*:::::::::::::::::::::::::::::::: FX  :::::::::::::::::::::::::::::::::::::*/
  52. FX::FX (const double *x, const double *y, int n) :
  53. x_((double*) x), y_((double*)y), nsteps_(n)
  54. {
  55. assert (n>=2);
  56. slope_ = new double[n];
  57. for (int i = 0; i<n-1; i++) 
  58. slope_[i] = (y[i+1] - y[i]) / (x[i+1] - x[i]);
  59. slope_[n-1] = slope_[n-2];
  60. }
  62. FX::~FX()
  63. {
  64. delete[] slope_;
  65. }
  67. double FX::LinearInterpolate (double xnew)
  68. {
  69. int i;
  71. // we should use binary search if nsteps is large, but for now...
  72. for (i=0; i<nsteps_-2; i++) {
  73. if (xnew < x_[i+1]) {
  74. return (y_[i] + slope_[i]*(xnew-x_[i]));
  75. }
  76. }
  78. return (y_[nsteps_-1] + slope_[nsteps_-1]*(xnew-x_[nsteps_-1]));
  79. }
  81. /*:::::::::::::::::::::::::::: Fractional ARIMA  ::::::::::::::::::::::::::::*/
  83. /** Reference:
  84.  * "Modeling Persistence in Hydrological Time Series 
  85.  * Using Fractional Differencing" 
  86.  * J.R.M. Hosking
  87.  * Water Resources Research, Vol 20, No 12, P1898-1908, Dec 1984
  88.  */
  90. /**
  91.  * y[t] = sum_j=1^p (AR[j] * y[t-j]) + x[t] - sum_j=1^q (MA[j] * x[t-j]
  92.  */
  94. #define Min(a, b)      ((a) < (b) ? (a) : (b))
  96. FARIMA::FARIMA(RNG* rng, double d, int N, int pAR, int qMA) :
  97. rng_(rng), N_(N), pAR_(pAR), qMA_(qMA), d_(d)
  98. {
  99. assert(N && qMA);
  101. if (pAR) {
  102. AR_ = new double[pAR];
  103. y_ = new double [pAR];
  104. }
  106. if (qMA)
  107. MA_ = new double[qMA];
  108. x_ = new double [N];
  109. phi_ = new double [N];
  111. /** use 1-theta[1] B-theta[2] B^2 - ..., and 
  112.  * our model is epsilon_j + epsilon_(j-1) 
  113.  */
  114. MA_[0] = -1; 
  116. for (int i=0; i<pAR; i++) 
  117. y_[i] = 0.0;
  119. t_ = tmod_ = 0;
  121. /* skip the first few in simulation to stablize */
  122. while (t_ < N + pAR + qMA)
  123. NextLow();
  124. }
  126. FARIMA::~FARIMA()
  127. {
  128. if (pAR_ > 0) { 
  129. delete[] AR_; 
  130. delete[] y_; 
  131. } 
  132. if (qMA_ > 0)
  133. delete[] MA_; 
  134. delete[] phi_;
  135. delete[] x_;
  136. }
  138. double FARIMA::NextLow()
  139. {
  140. int j;
  141. double mt, xt, yt, a, b, v0;
  143. if (t_ == 0) {
  144. /* d_0.25; gamma(1-2*d)/(gamma(1-d))^2 => 1.180341 */
  145. v0 = rng_->gammln(1.0-2.0*d_) - 2.0*rng_->gammln(1.0-d_);
  146. v0 = exp(v0);
  147. /* phi[0] is not used, so we use it for vt */
  148. phi_[0] = v0; 
  149. x_[t_] = rng_->rnorm() * pow(v0, 0.5);
  150. } else if (t_ < N_) {
  151. /* get phi_tt */
  152. phi_[t_] = d_/(t_-d_);
  153. /* get phi_tj */
  154. for (j=1; j<t_; j++) {
  155. if (j <= t_-j) {
  156. a = phi_[j] - phi_[t_] * phi_[t_-j];
  157. b = phi_[t_-j] - phi_[t_] * phi_[j];
  158. phi_[j] = a;
  159. phi_[t_-j] = b;
  160. }
  161. }
  162. /* get vt (phi[0]) */
  163. /* v[t] = (1-phi_tt^2) * v[t-1] */
  164. phi_[0] = (1-phi_[t_]*phi_[t_]) * phi_[0]; 
  165. }
  167. /* get m_t, v_t */
  168. mt = 0;
  169. for (j=1; j<=Min(t_,N_-1); j++)
  170. mt += phi_[j] * x_[(t_-j)%N_];
  172. /* get xt */
  173. xt = rng_->rnorm() * pow(phi_[0], 0.5) + mt;
  174. x_[t_%N_] = xt;
  176. /** add AR, MA parts only after enough points in the error 
  177.  * fARIMA process 
  178.  */
  179. yt = xt;
  180. if (t_ > qMA_) {
  181. if (qMA_ > 0) {
  182. for(j=0; j<qMA_; j++) 
  183. yt -= x_[(t_-1-j)%N_] * MA_[j];
  184. }
  185. }
  187. t_++;
  188. tmod_ = (++tmod_ == N_) ? 0 : tmod_;
  190. return (yt);
  191. }
  193. // assumes t > N and qMA < N
  194. double FARIMA::Next()
  195. {
  196. double mt, xt, yt;
  197. int j, m;
  199. /* get m_t, v_t */
  200. mt = 0;
  201. for (j=1; j<=tmod_; j++)
  202. mt += phi_[j] * x_[tmod_-j];
  204. for (j=tmod_+1; j<=N_-1; j++)
  205. mt += phi_[j] * x_[N_+tmod_-j];
  207. /* get xt */
  208. xt = rng_->rnorm() * pow(phi_[0], 0.5) + mt;
  209. x_[tmod_] = xt;
  211. /** add AR, MA parts only after enough points in the error 
  212.  * fARIMA process 
  213.  */
  214. yt = xt;
  215. if (t_>qMA_) {
  216. if (qMA_>0) {
  217. m = (tmod_ < qMA_) ? tmod_ : qMA_;
  218. for(j=0; j<m; j++) 
  219. yt -= x_[tmod_-1-j] * MA_[j];
  220. for(j=m; j<qMA_; j++) 
  221. yt -= x_[N_+tmod_-1-j] * MA_[j];
  222. }
  223. }
  225. t_++;
  226. tmod_ = (++tmod_ == N_) ? 0 : tmod_;
  228. return (yt);
  229. }
  231. /*:::::::::::::::::::::: PackMimeHTTP Transmission Delay RanVar :::::::::::::::::*/
  233. static class PackMimeHTTPXmitRandomVariableClass : public TclClass {
  234. public:
  235. PackMimeHTTPXmitRandomVariableClass() : 
  236. TclClass("RandomVariable/PackMimeHTTPXmit"){}
  237. TclObject* create(int argc, const char*const* argv) {
  238. if (argc == 6) {
  239. // rate, type
  240. return(new PackMimeHTTPXmitRandomVariable ((double) 
  241.    atof(argv[4]),
  242.    atoi(argv[5])));
  243. } else if (argc == 7) {
  244. // rate, type, RNG
  245. RNG* rng = (RNG*)TclObject::lookup(argv[6]);
  246. return(new PackMimeHTTPXmitRandomVariable ((double) 
  247.    atof(argv[4]), 
  248.    atoi(argv[5]),
  249.    rng));
  250. } else {
  251. return(new PackMimeHTTPXmitRandomVariable());
  252. }
  253. }
  254. } class_packmimexmitranvar;
  256. PackMimeHTTPXmitRandomVariable::PackMimeHTTPXmitRandomVariable() : 
  257. fARIMA_(NULL)
  258. {
  259. bind ("rate_", &rate_);
  260. bind ("type_", &type_);
  261. bind ("mean_", &mean_);
  262. bind ("const_", &const_);
  263. }
  265. PackMimeHTTPXmitRandomVariable::PackMimeHTTPXmitRandomVariable(double rate, 
  266.        int type) :
  267. rate_(rate), type_(type), const_(-1), mean_(-1), fARIMA_(NULL)
  268. {
  269. }
  271. PackMimeHTTPXmitRandomVariable::PackMimeHTTPXmitRandomVariable(double rate, 
  272.        int type, 
  273.        RNG* rng) :
  274.    rate_(rate), type_(type), const_(-1), mean_(-1), fARIMA_(NULL)
  275. {
  276. rng_ = rng;
  277. }
  279. PackMimeHTTPXmitRandomVariable::~PackMimeHTTPXmitRandomVariable() {
  280. if (fARIMA_)
  281. delete fARIMA_;
  282. }
  284. void PackMimeHTTPXmitRandomVariable::initialize() 
  285. {
  286. double sigmaTotal;
  287. struct arima_params * arima = & rtt_arima_params[type_];
  288. double d = arima->d;
  289.   
  290. assert(arima->N >= arima->qMA);
  291. varRatio_ = rng_->logitinv(arima->varRatioParam0 + 
  292.    arima->varRatioParam1 * log(rate_) / LOG2);
  293. sigmaTotal = 1.0;
  294. sigmaNoise_ = sigmaTotal * pow(varRatio_, 0.5);
  295. sigmaEpsilon_ = sigmaTotal * 
  296. pow(exp(2.0*rng_->gammln(1.0-d) - rng_->gammln(1.0-2.0*d)) 
  297.     / (2+2*d/(1-d)) * (1-varRatio_), 0.5);
  299. fARIMA_ = new FARIMA(rng_, arima->d, arima->N);
  300. }
  302. /* generate RTT according to the marginal distribution */
  303. double PackMimeHTTPXmitRandomVariable::value(void) {
  304. double yt, p;
  305.     
  306. if (fARIMA_ == NULL)
  307. initialize();
  309. yt = fARIMA_->Next();
  310. yt = yt * sigmaEpsilon_ + rng_->rnorm() * sigmaNoise_;
  311. p = rng_->pnorm(yt);
  312. p = -log(1-p)/log(10.0);
  313. yt = rtt_invcdf[type_].LinearInterpolate(p);
  314. yt = pow(yt, WEIBULL_SHAPE[type_]);
  316. // split in half for DelayBox -M. Weigle 9/17/01
  317. if (mean_ < 0)
  318. return(yt/2);
  319. else {
  320. if (const_ <0)
  321. const_ = mean_/avg();
  322. return(yt/2*const_);
  323. }
  324. } 
  326. double PackMimeHTTPXmitRandomVariable::avg(void) {
  327. if (type_)
  328. return 0.027;
  329. else
  330. return 0.058;
  331. }
  333. const double PackMimeHTTPXmitRandomVariable::SHORT_RTT_INVCDF_X[] = { 
  334. 0.00, 0.25, 0.50, 0.75, 1.00, 1.25, 1.50, 
  335. 1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 
  336. 3.50, 3.75, 4.00, 4.25, 4.50, 4.75, 5.00, 
  337. 5.30103
  338. };
  340. const double PackMimeHTTPXmitRandomVariable::SHORT_RTT_INVCDF_Y[] = {
  341. 0.87741, 1.07293, 1.10812, 1.86701, 2.04735, 2.30645, 2.90111, 
  342. 3.30185, 3.59297, 3.87927, 4.02239, 4.17551, 4.32119, 4.43112, 
  343. 4.57079, 4.66087, 4.73359, 4.78683, 4.84591, 4.91282, 4.95503, 
  344. 5.01453
  345. };
  347. const double PackMimeHTTPXmitRandomVariable::LONG_RTT_INVCDF_X[]={ 
  348. 0.00, 0.25, 0.50, 0.75, 1.00, 1.25, 1.50,  
  349. 1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 4.00
  350. };
  351. const double PackMimeHTTPXmitRandomVariable::LONG_RTT_INVCDF_Y[]={
  352. 0.79105, 3.71848, 4.46097, 4.49838, 4.84954, 5.78215, 6.77357, 
  353. 7.78683, 8.75032, 10.3434, 11.4477, 14.0272, 14.6139, 17.2251
  354. };
  356. struct arima_params PackMimeHTTPXmitRandomVariable::rtt_arima_params[] = {
  357. { 0.31,    /* d */
  358.   1000,    /* number of finite AR rep of farima */
  359.   -0.445,  /* varRatioParam0 */
  360.   0.554,   /* varRatioParam1 */
  361.   0, 1     /* pAR=0, qMA */
  362. },
  363. { 0.32,    /* d */
  364.   1000,    /* number of finite AR rep of farima */
  365.   -0.053,  /* varRatioParam0 */
  366.   0.396,   /* varRatioParam1 */
  367.   0, 1     /* pAR=0, qMA */
  368. }
  369. };
  371. FX PackMimeHTTPXmitRandomVariable::rtt_invcdf[2] = {
  372. FX (SHORT_RTT_INVCDF_X, SHORT_RTT_INVCDF_Y, 
  373.     sizeof (SHORT_RTT_INVCDF_X) / sizeof(double)),
  374. FX (LONG_RTT_INVCDF_X, LONG_RTT_INVCDF_Y, 
  375.     sizeof (LONG_RTT_INVCDF_X) / sizeof(double))
  376. };
  378. const double PackMimeHTTPXmitRandomVariable::WEIBULL_SHAPE[2] = { 5, 3 };
  380. /*:::::::::::::::::::::: PackMimeHTTP Flow Arrival RanVar ::::::::::::::::::::::*/
  382. /**
  383.  * This random variable includes both flow interarrivals for non-persistent
  384.  * connections and persistent connections.  This RV is sampled during
  385.  * connection setup.  It will return an array of interarrivals.  The first
  386.  * element in the array wil be the number of requests in this connection.  If
  387.  * the number of elements is 1, then the connection is non-persistent.  If the
  388.  * number of elements is > 1, then the connection is persistent.  
  389.  */
  391. static class PackMimeHTTPFlowArriveRandomVariableClass : public TclClass {
  392. public:
  393. PackMimeHTTPFlowArriveRandomVariableClass() : 
  394. TclClass("RandomVariable/PackMimeHTTPFlowArrive"){}
  395. TclObject* create(int argc, const char*const* argv) {
  396. if (argc == 5) {
  397. // rate
  398. return(new PackMimeHTTPFlowArriveRandomVariable 
  399.        ((double) atof(argv[4])));
  400. } else if (argc == 6) {
  401. // rate, RNG
  402. RNG* rng = (RNG*)TclObject::lookup(argv[5]);
  403. return(new PackMimeHTTPFlowArriveRandomVariable ((double) 
  404.  atof(argv[4]), 
  405.  rng));
  406. } else {
  407. return(new PackMimeHTTPFlowArriveRandomVariable());
  408. }
  409. }
  410. } class_packmimeflowarriveranvar;
  413. PackMimeHTTPFlowArriveRandomVariable::PackMimeHTTPFlowArriveRandomVariable() : 
  414. const_(1), mean_(0), fARIMA_(NULL)
  415. {
  416. bind ("rate_", &rate_);
  417. }
  419. PackMimeHTTPFlowArriveRandomVariable::PackMimeHTTPFlowArriveRandomVariable(double rate) :
  420. rate_(rate), const_(1), mean_(0), fARIMA_(NULL)
  421. {
  422. }
  424. PackMimeHTTPFlowArriveRandomVariable::PackMimeHTTPFlowArriveRandomVariable(double rate, 
  425.    RNG* rng) :
  426. rate_(rate), const_(1), mean_(0), fARIMA_(NULL)
  427. {
  428. rng_ = rng;
  429. }
  431. PackMimeHTTPFlowArriveRandomVariable::~PackMimeHTTPFlowArriveRandomVariable() 
  432. {
  433. if (fARIMA_)
  434. delete fARIMA_;
  435. }
  437. void PackMimeHTTPFlowArriveRandomVariable::initialize() {
  438. double sigmaTotal;
  439. struct arima_params *arima = &flowarrive_arima_params;
  440. double d = arima->d;
  441. int N = arima->N;
  442. // New model Added by Y. Gao June 2003
  443. d = 0.33;
  445. varRatio_ = rng_->logitinv(0.333+0.414*log(rate_)/LOG2); 
  446. sigmaTotal = 1.0;
  447. sigmaNoise_ = sigmaTotal * pow(varRatio_,0.5);
  448. sigmaEpsilon_ = sigmaTotal * pow (exp (2.0 * rng_->gammln(1.0-d) - 
  449.        rng_->gammln(1.0-2.0*d)) / 
  450.   (2+2*d/(1-d)) * (1-varRatio_), 0.5);
  451. weibullShape_ = rng_->logitinv(0.352+0.388*log(rate_)/LOG2);
  452. weibullScale_ = 1.0 / (rate_ * exp(rng_->gammln(1+1.0/weibullShape_)));
  453. fARIMA_ = new FARIMA(rng_, d, N);
  454. }
  456. double PackMimeHTTPFlowArriveRandomVariable::avg(void) {
  457. return 4.3018;
  458. }
  460. double PackMimeHTTPFlowArriveRandomVariable::avg(int gap_type_) {
  461. if (gap_type_ == 0) {
  462. return 0.0262;
  463. }
  464. else {
  465. return 3.32;
  466. }
  467. }
  469. /* generate flow rate according to the marginal distribution */
  470. double PackMimeHTTPFlowArriveRandomVariable::value(void) {
  471. double yt;
  473. if (fARIMA_ == NULL) 
  474. initialize();
  476. yt = fARIMA_->Next();
  477. yt = yt * sigmaEpsilon_ + rng_->rnorm() * sigmaNoise_;
  478. yt = rng_->qweibull(rng_->pnorm(yt), weibullShape_, weibullScale_);
  480. // adjust by const_ and mean_ (by default, this does nothing)
  481. if (const_ == 0) {
  482. const_ = mean_ / avg(1);
  483. }
  485. return(yt * const_);
  486. }
  488. struct arima_params PackMimeHTTPFlowArriveRandomVariable::flowarrive_arima_params =
  489. {
  490. 0.35,       /* d */
  491. 1000,       /* number of finite AR rep of farima */
  492. -1.2811,    /* varRatioParam0 */
  493. -0.3150,    /* varRatioParam1 */
  494. 0, 1        /* pAR=0, qMA */
  495. };
  497. /*:::::::::::::::::::::: PackMimeHTTP File Size RanVar :::::::::::::::::::::*/
  499. static class PackMimeHTTPFileSizeRandomVariableClass : public TclClass {
  500. public:
  501. PackMimeHTTPFileSizeRandomVariableClass() : 
  502.   TclClass("RandomVariable/PackMimeHTTPFileSize"){}
  503. TclObject* create(int argc, const char*const* argv) {
  504. if (argc == 6) {
  505.   // rate, type
  506.   return(new PackMimeHTTPFileSizeRandomVariable 
  507.  ((double) atof(argv[4]), atoi(argv[5])));
  508. } else if (argc == 7) {
  509.   // rate, type, RNG
  510.   RNG* rng = (RNG*)TclObject::lookup(argv[6]);
  511.   return(new PackMimeHTTPFileSizeRandomVariable ((double) 
  512.        atof(argv[4]), 
  513.        atoi(argv[5]),
  514.        rng));
  515. } else {
  516. return(new PackMimeHTTPFileSizeRandomVariable());
  517. }
  518.  }
  519. } class_packmimefilesizeranvar;
  522. PackMimeHTTPFileSizeRandomVariable::PackMimeHTTPFileSizeRandomVariable() : 
  523.   const_(1), mean_(0), fARIMA_(NULL)
  524. {
  525. bind ("rate_", &rate_);
  526. bind ("type_", &type_);
  527. }
  529. PackMimeHTTPFileSizeRandomVariable::PackMimeHTTPFileSizeRandomVariable(double rate, int type) :
  530.   rate_(rate), type_(type), const_(1), mean_(0), fARIMA_(NULL)
  531. {
  532. }
  534. PackMimeHTTPFileSizeRandomVariable::PackMimeHTTPFileSizeRandomVariable(double rate, int type, RNG* rng) :
  535.   rate_(rate), type_(type), const_(1), mean_(0), fARIMA_(NULL)
  536. {
  537. rng_ = rng;
  538. }
  541. PackMimeHTTPFileSizeRandomVariable::~PackMimeHTTPFileSizeRandomVariable() 
  542. {
  543. if (fARIMA_)
  544. delete fARIMA_;
  545. }
  547. void PackMimeHTTPFileSizeRandomVariable::initialize() 
  548. {
  549. double sigmaTotal;
  550. struct arima_params *arima = &filesize_arima_params;
  551. double d = arima->d;
  552. int N = arima->N;
  553.  
  554. /* fsize0 run length */
  555. state_ = 0;
  556. runlen_ = 0;
  558. /* fsize1 */
  559. sigmaTotal = 1.0;
  560. varRatio_ = rng_->logitinv(FSIZE1_VARRATIO_INTERCEPT + 
  561.    FSIZE1_VARRATIO_SLOPE * log(rate_)/LOG2);
  562. sigmaNoise_ = sigmaTotal * pow(varRatio_,0.5);
  563. sigmaEpsilon_ = sigmaTotal * 
  564. pow(exp (2.0 * rng_->gammln(1.0-d) - 
  565.  rng_->gammln(1.0-2.0*d)) / 
  566.     (2+2*d/(1-d)) * (1-varRatio_), 0.5);
  568. /* fsize0 runlen */
  569. shape_[0] = rng_->logitinv(0.718+0.357*log(rate_)/LOG2);
  570. shape_[1] = rng_->logitinv(1.293+0.316*log(rate_)/LOG2);
  571. scale_[0] = 0.775;
  572. scale_[1] = 3.11;
  574. /* simulate */
  575. fARIMA_ = new FARIMA(rng_, d, N);
  576. }
  578. /** random generate the marginal distribution of fsize0 depending
  579.  *  on whether it is a cache validation (0) or downloaded file (1).
  580.  */
  581. int PackMimeHTTPFileSizeRandomVariable::rfsize0(int state)
  582. {
  583. double yt, p;
  584.   
  585. p = rng_->uniform();
  586. if (state==1) 
  587. p = log(1-p)/LOG2; 
  588. yt = fsize_invcdf[0][state].LinearInterpolate(p);
  589. if (state==1) 
  590. yt = exp(LOG2*yt); 
  592. return((int) yt);
  593. }
  595. /* given a probability, find the corresponding quantile of fsize1. */
  596. int PackMimeHTTPFileSizeRandomVariable::qfsize1(double p)
  597. {
  598. int state;
  599. double yt;
  601. /* first convert this to conditional probablity */
  602. if(p > FSIZE1_PROB_A){
  603. state = 1; 
  604. p = (p-FSIZE1_PROB_A)/(1-FSIZE1_PROB_A);
  605. }else {
  606. state = 0;
  607. p = p/FSIZE1_PROB_A;
  608. }
  610. if (state==1) 
  611. p=log(1-p)/LOG2;
  612. yt = fsize_invcdf[1][state].LinearInterpolate(p);
  613. if (state==1) 
  614. yt=exp(LOG2*yt); 
  616. return((int) yt);
  617. }
  619. double PackMimeHTTPFileSizeRandomVariable::avg(void) {
  620. if (type_ == PACKMIME_RSP_SIZE) {
  621. return 2272;
  622. }
  623. else {
  624. return 423;
  625. }
  626. }
  628. /* obtain the next server file size */
  629. double PackMimeHTTPFileSizeRandomVariable::value() 
  630. {
  631. int yt;
  633. if (fARIMA_ == NULL)
  634. initialize();
  636. if (type_ == PACKMIME_RSP_SIZE) {
  637. /* regenerate the runlen if a run is finished */
  638. if (runlen_ <= 0) { // XXX Y. G. changed to <= from ==
  639. state_ = 1-state_;
  640. runlen_ = (int) ceil(rng_->rweibull(shape_[state_], 
  641.     scale_[state_]));
  642. }
  643. yt = rfsize0(state_); 
  644. runlen_--;
  646. // adjust by const_ and mean_ (by default, this does nothing)
  647. if (const_ == 0) {
  648. const_ = mean_ / avg();
  649. }
  650. return (double) (yt * const_);
  651. } else if (type_ == PACKMIME_REQ_SIZE) {
  652. double yx;
  653. yx = fARIMA_->Next();
  654. yx = yx * sigmaEpsilon_ + rng_->rnorm() * sigmaNoise_;
  655. yt = qfsize1(rng_->pnorm(yx));
  657. // adjust by const_ and mean_ (by default, this does nothing)
  658. if (const_ == 0) {
  659. const_ = mean_ / avg();
  660. }
  661. return (double) (yt * const_);
  662. }
  663. return 0;
  664. }
  666. /* fitted inverse cdf curves for file sizes  */
  667. const double PackMimeHTTPFileSizeRandomVariable::FSIZE0_INVCDF_A_X[]={ 
  668. 1e-04, 0.0102, 0.0203, 0.0304, 0.0405, 0.0506, 0.0607, 0.0708, 
  669. 0.0809, 0.091, 0.1011, 0.1112, 0.1213, 0.1314, 0.1415, 0.1516, 
  670. 0.1617, 0.1718, 0.1819, 0.192, 0.2021, 0.2122, 0.2223, 0.2324, 
  671. 0.2425, 0.2526, 0.2627, 0.2728, 0.2829, 0.293, 0.3031, 0.3132, 
  672. 0.3233, 0.3334, 0.3435, 0.3536, 0.3637, 0.3738, 0.3839, 0.394, 
  673. 0.4041, 0.4142, 0.4243, 0.4344, 0.4445, 0.4546, 0.4647, 0.4748, 
  674. 0.4849, 0.495, 0.5051, 0.5152, 0.5253, 0.5354, 0.5455, 0.5556, 
  675. 0.5657, 0.5758, 0.5859, 0.596, 0.6061, 0.6162, 0.6263, 0.6364, 
  676. 0.64649, 0.65659, 0.66669, 0.67679, 0.68689, 0.69699, 0.70709, 
  677. 0.71719, 0.72729, 0.73739, 0.74749, 0.75759, 0.76769, 0.77779, 
  678. 0.78789, 0.79799, 0.80809, 0.81819, 0.82829, 0.83839, 0.84849, 
  679. 0.85859, 0.86869, 0.87879, 0.88889, 0.89899, 0.90909, 0.91919, 
  680. 0.92929, 0.93939, 0.94949, 0.95959, 0.96969, 0.97979, 0.98989, 
  681. 0.99999
  682. }; 
  684. const double PackMimeHTTPFileSizeRandomVariable::FSIZE0_INVCDF_A_Y[]={ 
  685. 4.645, 22.7357, 40.8041, 53.0108, 61.468, 64.4307, 67.3933, 69.6925, 
  686. 71.3981, 73.1037, 74.8092, 80.6677, 87.4875, 93.5693, 97.6514, 
  687. 101.249, 104.58, 107.021, 109.195, 111.087, 112.752, 114.273, 
  688. 115.545, 116.78, 118.014, 119.248, 120.483, 121.551, 122.51, 123.441, 
  689. 124.312, 125.119, 125.927, 126.734, 127.524, 128.288, 129.053, 
  690. 129.818, 130.582, 131.347, 132.143, 132.973, 133.835, 134.71, 
  691. 135.603, 136.537, 137.47, 138.404, 139.337, 140.28, 141.233, 142.186, 
  692. 143.139, 144.092, 145.045, 145.979, 146.904, 147.816, 148.71, 
  693. 149.589, 150.485, 151.478, 152.703, 153.928, 155.403, 157.294, 
  694. 159.389, 161.953, 165.018, 168.54, 172.7, 177.629, 183.365, 189.766, 
  695. 195.845, 200.636, 203.987, 206.43, 208.611, 211.114, 214.424, 
  696. 218.008, 221.925, 225.722, 229.242, 232.747, 236.235, 239.952, 
  697. 244.076, 248.68, 253.434, 257.857, 261.539, 264.471, 266.742, 
  698. 268.487, 269.793, 270.794, 271.571, 272.234
  699. }; 
  701. const double PackMimeHTTPFileSizeRandomVariable::FSIZE0_INVCDF_B_X[]={ 
  702. -18.1793, -17.9957, -17.8121, -17.6285, -17.4449, -17.2613, -17.0777, 
  703. -16.8941, -16.7104, -16.5268, -16.3432, -16.1596, -15.976, -15.7924, 
  704. -15.6088, -15.4252, -15.2415, -15.0579, -14.8743, -14.6907, -14.5071, 
  705. -14.3235, -14.1399, -13.9563, -13.7726, -13.589, -13.4054, -13.2218, 
  706. -13.0382, -12.8546, -12.671, -12.4874, -12.3038, -12.1201, -11.9365, 
  707. -11.7529, -11.5693, -11.3857, -11.2021, -11.0185, -10.8349, -10.6513, 
  708. -10.4677, -10.284, -10.1004, -9.91682, -9.7332, -9.54959, -9.36598, 
  709. -9.18237, -8.99876, -8.81515, -8.63154, -8.44792, -8.26431, -8.0807, 
  710. -7.89709, -7.71348, -7.52987, -7.34626, -7.16265, -6.97903, -6.79542, 
  711. -6.61181, -6.4282, -6.24459, -6.06098, -5.87737, -5.69376, -5.51014, 
  712. -5.32653, -5.14292, -4.95931, -4.7757, -4.59209, -4.40848, -4.22486, 
  713. -4.04125, -3.85764, -3.67403, -3.49042, -3.30681, -3.1232, -2.93959, 
  714. -2.75597, -2.57236, -2.38875, -2.20514, -2.02153, -1.83792, -1.65431, 
  715. -1.47069, -1.28708, -1.10347, -0.91986, -0.73625, -0.55264, -0.36903, 
  716. -0.18542, -0.0018
  717. }; 
  719. const double PackMimeHTTPFileSizeRandomVariable::FSIZE0_INVCDF_B_Y[]={ 
  720. 25.8765, 25.7274, 25.5782, 25.4291, 25.2799, 25.1308, 24.9817, 
  721. 24.8325, 24.6834, 24.5342, 24.3851, 24.2359, 24.0868, 23.9377, 
  722. 23.7885, 23.6394, 23.4902, 23.3411, 23.1919, 23.0428, 22.8937, 
  723. 22.7445, 22.5954, 22.4462, 22.2971, 22.1479, 21.9988, 21.8497, 
  724. 21.7005, 21.5514, 21.4022, 21.2531, 21.104, 20.9548, 20.8057, 
  725. 20.6565, 20.5074, 20.3582, 20.2091, 20.06, 19.9108, 19.7617, 19.6125, 
  726. 19.4634, 19.3143, 19.1651, 19.016, 18.8668, 18.7177, 18.5685, 
  727. 18.4194, 18.2703, 18.1211, 17.972, 17.8228, 17.6737, 17.5245, 
  728. 17.3754, 17.2263, 17.0771, 16.928, 16.7788, 16.6297, 16.4806, 
  729. 16.3314, 16.1823, 16.0331, 15.8842, 15.739, 15.6026, 15.4804, 
  730. 15.3778, 15.3003, 15.2465, 15.2045, 15.1597, 15.0978, 15.0044, 
  731. 14.8675, 14.6932, 14.4968, 14.2932, 14.0976, 13.9248, 13.7783, 
  732. 13.6435, 13.5042, 13.3444, 13.1478, 12.9005, 12.6008, 12.2512, 
  733. 11.8545, 11.4133, 10.9303, 10.4104, 9.86075, 9.28886, 8.70213, 
  734. 8.10797
  735. }; 
  737. const double PackMimeHTTPFileSizeRandomVariable::FSIZE1_INVCDF_A_X[]={ 
  738. 3e-05, 0.01013, 0.02023, 0.03033, 0.04043, 0.05053, 0.06063, 0.07074, 
  739. 0.08084, 0.09094, 0.10104, 0.11114, 0.12124, 0.13134, 0.14144, 
  740. 0.15154, 0.16164, 0.17174, 0.18184, 0.19194, 0.20204, 0.21214, 
  741. 0.22225, 0.23235, 0.24245, 0.25255, 0.26265, 0.27275, 0.28285, 
  742. 0.29295, 0.30305, 0.31315, 0.32325, 0.33335, 0.34345, 0.35355, 
  743. 0.36365, 0.37376, 0.38386, 0.39396, 0.40406, 0.41416, 0.42426, 
  744. 0.43436, 0.44446, 0.45456, 0.46466, 0.47476, 0.48486, 0.49496, 
  745. 0.50506, 0.51516, 0.52526, 0.53537, 0.54547, 0.55557, 0.56567, 
  746. 0.57577, 0.58587, 0.59597, 0.60607, 0.61617, 0.62627, 0.63637, 
  747. 0.64647, 0.65657, 0.66667, 0.67677, 0.68688, 0.69698, 0.70708, 
  748. 0.71718, 0.72728, 0.73738, 0.74748, 0.75758, 0.76768, 0.77778, 
  749. 0.78788, 0.79798, 0.80808, 0.81818, 0.82828, 0.83839, 0.84849, 
  750. 0.85859, 0.86869, 0.87879, 0.88889, 0.89899, 0.90909, 0.91919, 
  751. 0.92929, 0.93939, 0.94949, 0.95959, 0.96969, 0.97979, 0.98989, 1
  752. }; 
  754. const double PackMimeHTTPFileSizeRandomVariable::FSIZE1_INVCDF_A_Y[]={ 
  755. 50.9777, 93.8217, 123.301, 146.594, 168.813, 184.263, 193.95, 
  756. 200.037, 204.696, 210.069, 217.623, 226.668, 236.226, 245.269, 
  757. 253.057, 259.624, 265.16, 269.811, 273.754, 277.165, 280.193, 
  758. 283.062, 285.893, 288.79, 291.744, 294.738, 297.754, 300.776, 
  759. 303.784, 306.763, 309.698, 312.564, 315.349, 318.042, 320.624, 
  760. 323.107, 325.49, 327.782, 329.987, 332.11, 334.159, 336.135, 338.047, 
  761. 339.898, 341.695, 343.443, 345.145, 346.808, 348.439, 350.04, 
  762. 351.619, 353.177, 354.716, 356.239, 357.744, 359.233, 360.709, 
  763. 362.17, 363.619, 365.056, 366.483, 367.9, 369.31, 370.711, 372.106, 
  764. 373.496, 374.881, 376.263, 377.643, 379.021, 380.399, 381.778, 
  765. 383.159, 384.542, 385.929, 387.321, 388.719, 390.121, 391.528, 
  766. 392.939, 394.355, 395.775, 397.199, 398.626, 400.057, 401.491, 
  767. 402.928, 404.368, 405.81, 407.255, 408.702, 410.151, 411.602, 
  768. 413.054, 414.508, 415.963, 417.418, 418.874, 420.331, 421.788
  769. }; 
  771. const double PackMimeHTTPFileSizeRandomVariable::FSIZE1_INVCDF_B_X[]={ 
  772. -17.7791, -17.5996, -17.4201, -17.2406, -17.0611, -16.8816, -16.7021, 
  773. -16.5226, -16.3431, -16.1635, -15.984, -15.8045, -15.625, -15.4455, 
  774. -15.266, -15.0865, -14.907, -14.7275, -14.548, -14.3685, -14.189, 
  775. -14.0095, -13.83, -13.6505, -13.471, -13.2915, -13.112, -12.9325, 
  776. -12.753, -12.5735, -12.394, -12.2145, -12.035, -11.8555, -11.676, 
  777. -11.4965, -11.317, -11.1375, -10.958, -10.7785, -10.599, -10.4194, 
  778. -10.24, -10.0604, -9.88094, -9.70144, -9.52193, -9.34243, -9.16293, 
  779. -8.98342, -8.80392, -8.62442, -8.44491, -8.26541, -8.08591, -7.9064, 
  780. -7.7269, -7.5474, -7.3679, -7.18839, -7.00889, -6.82939, -6.64988, 
  781. -6.47038, -6.29088, -6.11137, -5.93187, -5.75237, -5.57286, -5.39336, 
  782. -5.21386, -5.03435, -4.85485, -4.67535, -4.49584, -4.31634, -4.13684, 
  783. -3.95733, -3.77783, -3.59833, -3.41883, -3.23932, -3.05982, -2.88032, 
  784. -2.70081, -2.52131, -2.34181, -2.1623, -1.9828, -1.8033, -1.62379, 
  785. -1.44429, -1.26479, -1.08528, -0.90578, -0.72628, -0.54678, -0.36727, 
  786. -0.18777, -0.00827
  787. }; 
  789. const double PackMimeHTTPFileSizeRandomVariable::FSIZE1_INVCDF_B_Y[]={ 
  790. 19.7578, 19.6369, 19.5159, 19.3949, 19.274, 19.153, 19.032, 18.9111, 
  791. 18.7901, 18.6691, 18.5482, 18.4272, 18.3063, 18.1853, 18.0643, 
  792. 17.9434, 17.8224, 17.7014, 17.5805, 17.4595, 17.3386, 17.2176, 
  793. 17.0966, 16.9757, 16.8547, 16.7337, 16.6128, 16.4918, 16.3708, 
  794. 16.2499, 16.1289, 16.0079, 15.887, 15.766, 15.6451, 15.5241, 15.4031, 
  795. 15.2822, 15.1612, 15.0402, 14.9193, 14.7983, 14.6774, 14.5564, 
  796. 14.4354, 14.3145, 14.1935, 14.0725, 13.9516, 13.8306, 13.7096, 
  797. 13.5887, 13.4677, 13.3468, 13.2258, 13.1048, 12.9839, 12.8629, 
  798. 12.7419, 12.621, 12.5, 12.3791, 12.2581, 12.1371, 12.0162, 11.8952, 
  799. 11.7742, 11.6533, 11.5323, 11.4113, 11.2904, 11.1694, 11.0485, 
  800. 10.9275, 10.8065, 10.6856, 10.5646, 10.4436, 10.3239, 10.2092, 
  801. 10.1034, 10.0105, 9.93459, 9.87896, 9.8393, 9.80562, 9.76884, 
  802. 9.71919, 9.64712, 9.54737, 9.42776, 9.29852, 9.16992, 9.05219, 
  803. 8.95525, 8.88155, 8.82669, 8.78593, 8.75459, 8.72795
  804. };
  806. const double PackMimeHTTPFileSizeRandomVariable:: FSIZE1_PROB_A=0.5;
  807. const double PackMimeHTTPFileSizeRandomVariable:: FSIZE1_D=0.31;
  808. const double PackMimeHTTPFileSizeRandomVariable:: FSIZE1_VARRATIO_INTERCEPT=0.123;
  809. const double PackMimeHTTPFileSizeRandomVariable:: FSIZE1_VARRATIO_SLOPE=0.494;
  810. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSCALECACHERUN = 1.1341;
  811. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSHAPECACHERUN_ASYMPTOE = 0.82;
  812. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSHAPECACHERUN_PARA1 = 0.6496;
  813. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSHAPECACHERUN_PARA2 = 0.0150;
  814. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSHAPECACHERUN_PARA3 = 1.5837;
  815. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSCALEDOWNLOADRUN = 3.0059;
  816. const double PackMimeHTTPFileSizeRandomVariable:: WEIBULLSHAPEDOWNLOADRUN = 0.82;
  818. const double PackMimeHTTPFileSizeRandomVariable::FSIZE0_PARA[] = {
  819. WEIBULLSHAPECACHERUN_ASYMPTOE,
  820. WEIBULLSHAPECACHERUN_PARA1,
  821. WEIBULLSHAPECACHERUN_PARA2,
  822. WEIBULLSHAPECACHERUN_PARA3
  823. };
  825. const double* PackMimeHTTPFileSizeRandomVariable::P = FSIZE0_PARA;
  827. const int PackMimeHTTPFileSizeRandomVariable::FSIZE0_CACHE_CUTOFF=275; 
  828. const int PackMimeHTTPFileSizeRandomVariable::FSIZE0_STRETCH_THRES=400;
  829. const double PackMimeHTTPFileSizeRandomVariable:: M_FSIZE0_NOTCACHE = 10.50;
  830. const double PackMimeHTTPFileSizeRandomVariable:: V_FSIZE0_NOTCACHE = 3.23; 
  831. const double PackMimeHTTPFileSizeRandomVariable:: M_LOC = 10.62;      
  832. const double PackMimeHTTPFileSizeRandomVariable:: V_LOC = 0.94;       
  833. const double PackMimeHTTPFileSizeRandomVariable:: SHAPE_SCALE2 = 3.22;
  834. const double PackMimeHTTPFileSizeRandomVariable:: RATE_SCALE2 = 3.22; 
  835. const double PackMimeHTTPFileSizeRandomVariable:: V_ERROR = 2.43;
  837. struct arima_params PackMimeHTTPFileSizeRandomVariable::filesize_arima_params  = {
  838. FSIZE1_D,   /* d */
  839. 5000,       /* number of finite AR rep of farima */
  840. 0,          /* varRatioParam0 */
  841. 0,          /* varRatioParam1 */
  842. 0, 1        /* pAR=0, qMA */
  843. };
  845. FX PackMimeHTTPFileSizeRandomVariable::fsize_invcdf[2][2] = {
  846. { FX(FSIZE0_INVCDF_A_X, FSIZE0_INVCDF_A_Y, 
  847.      sizeof(FSIZE0_INVCDF_A_X)/sizeof(double)), 
  848.   FX(FSIZE0_INVCDF_B_X, FSIZE0_INVCDF_B_Y,
  849.      sizeof(FSIZE0_INVCDF_B_X)/sizeof(double))
  850. },
  851. { FX(FSIZE1_INVCDF_A_X, FSIZE1_INVCDF_A_Y,
  852.      sizeof(FSIZE1_INVCDF_A_X)/sizeof(double)),
  853.   FX(FSIZE1_INVCDF_B_X, FSIZE1_INVCDF_B_Y,
  854.      sizeof(FSIZE1_INVCDF_B_X)/sizeof(double))
  855. }
  856. };
  858. /*:::::::::::::::::::::: PackMimeHTTP Persistent Response Size RanVar ::::::::::::::::::*/
  861. static class PackMimeHTTPPersistRspSizeRandomVariableClass : public TclClass {
  862. public:
  863. PackMimeHTTPPersistRspSizeRandomVariableClass() : 
  864. TclClass("RandomVariable/PackMimeHTTPPersistRspSize"){}
  865. TclObject* create(int argc, const char*const* argv) {
  866. return(new PackMimeHTTPPersistRspSizeRandomVariable());
  867. }
  868. } class_packmimepersistrspsizeranvar;
  871. PackMimeHTTPPersistRspSizeRandomVariable::PackMimeHTTPPersistRspSizeRandomVariable() : 
  872. loc_(-1), scale_(-1)
  873. {
  874. rng_ = new RNG();
  875. }
  877. PackMimeHTTPPersistRspSizeRandomVariable::PackMimeHTTPPersistRspSizeRandomVariable(RNG* rng) : 
  878. loc_(-1), scale_(-1)
  879. {
  880. rng_ = rng;
  881. }
  883. PackMimeHTTPPersistRspSizeRandomVariable::~PackMimeHTTPPersistRspSizeRandomVariable() 
  884. {
  885. if (rng_)
  886. delete rng_;
  887. }
  889. double PackMimeHTTPPersistRspSizeRandomVariable::value()
  890. {
  891. double interrand;
  892. double interres; 
  894. if (loc_ == -1 || scale_ == -1) {
  895. loc_ = rng_->rnorm() * sqrt(V_LOC) + M_LOC;
  896. scale_ = rng_->rgamma(SHAPE_SCALE2, 1/RATE_SCALE2);
  897. }
  899. interrand = rng_->rnorm();
  900. interres = loc_ + sqrt(scale_) * interrand * sqrt(V_ERROR);  
  901. return pow(2.0, interres);
  902. }
  904. double PackMimeHTTPPersistRspSizeRandomVariable::avg()
  905. {
  906. return 0;
  907. }
  909. const int PackMimeHTTPPersistRspSizeRandomVariable::FSIZE_CACHE_CUTOFF=275; 
  910. const double PackMimeHTTPPersistRspSizeRandomVariable::M_LOC = 10.62;
  911. const double PackMimeHTTPPersistRspSizeRandomVariable::V_LOC = 0.94;
  912. const double PackMimeHTTPPersistRspSizeRandomVariable::SHAPE_SCALE2 = 3.22;
  913. const double PackMimeHTTPPersistRspSizeRandomVariable::RATE_SCALE2 = 3.22;
  914. const double PackMimeHTTPPersistRspSizeRandomVariable::V_ERROR = 2.43;
  916. /*:::::::::::::::::::::: PackMimeHTTP Persistent RanVar :::::::::::::::::::::::::*/
  918. static class PackMimeHTTPPersistentRandomVariableClass : public TclClass {
  919. public:
  920. PackMimeHTTPPersistentRandomVariableClass() : 
  921. TclClass("RandomVariable/PackMimeHTTPPersistent"){}
  922. TclObject* create(int argc, const char*const* argv) {
  923. if (argc == 5) {
  924. // probability
  925. return(new PackMimeHTTPPersistentRandomVariable 
  926.        ((double) atof(argv[4])));
  927. } else if (argc == 6) {
  928. // probability, RNG
  929. RNG* rng = (RNG*)TclObject::lookup(argv[5]);
  930. return(new PackMimeHTTPPersistentRandomVariable ((double) 
  931.  atof(argv[4]), 
  932.  rng));
  933. } else {
  934. return(new PackMimeHTTPPersistentRandomVariable());
  935. }
  936. }
  937. } class_packmimepersistentranvar;
  940. PackMimeHTTPPersistentRandomVariable::PackMimeHTTPPersistentRandomVariable()
  941. {
  942. bind ("probability_", &probability_);
  943. }
  945. PackMimeHTTPPersistentRandomVariable::PackMimeHTTPPersistentRandomVariable(double prob) :
  946. probability_(prob)
  947. {
  948. }
  950. PackMimeHTTPPersistentRandomVariable::PackMimeHTTPPersistentRandomVariable(double prob, 
  951.    RNG* rng) :
  952. probability_(prob)
  953. {
  954. rng_ = rng;
  955. }
  957. double PackMimeHTTPPersistentRandomVariable::value(void)
  958. {
  959. return ((double) rng_->rbernoulli (probability_));
  960. }
  962. const double PackMimeHTTPPersistentRandomVariable::P_PERSISTENT = 0.09;
  964. /*:::::::::::::::::::::: PackMimeHTTP Num Pages RanVar :::::::::::::::::::::::::*/
  966. static class PackMimeHTTPNumPagesRandomVariableClass : public TclClass {
  967. public:
  968. PackMimeHTTPNumPagesRandomVariableClass() : 
  969. TclClass("RandomVariable/PackMimeHTTPNumPages"){}
  970. TclObject* create(int argc, const char*const* argv) {
  971. if (argc == 7) {
  972. // probability, shape, scale
  973. return(new PackMimeHTTPNumPagesRandomVariable 
  974.        ((double) atof(argv[4]), (double) atof(argv[5]), 
  975. (double) atof(argv[6])));
  976. } else if (argc == 8) {
  977. // probability, shape, scale, RNG
  978. RNG* rng = (RNG*)TclObject::lookup(argv[7]);
  979. return(new PackMimeHTTPNumPagesRandomVariable 
  980.        ((double) atof(argv[4]), (double) atof(argv[5]),
  981. (double) atof(argv[6]), rng));
  982. } else {
  983. return(new PackMimeHTTPNumPagesRandomVariable());
  984. }
  985. }
  986. } class_packmimenumpagesranvar;
  989. PackMimeHTTPNumPagesRandomVariable::PackMimeHTTPNumPagesRandomVariable() :
  990. probability_(P_1PAGE), shape_(SHAPE_NPAGE), scale_(SCALE_NPAGE)
  991. {
  992. }
  994. PackMimeHTTPNumPagesRandomVariable::PackMimeHTTPNumPagesRandomVariable(double prob, 
  995.        double shape,
  996.        double scale) :
  997. probability_(prob), shape_(shape), scale_(scale)
  998. {
  999. }
  1001. PackMimeHTTPNumPagesRandomVariable::PackMimeHTTPNumPagesRandomVariable(double prob, 
  1002.        double shape,
  1003.        double scale,
  1004.        RNG* rng) :
  1005. probability_(prob), shape_(shape), scale_(scale)
  1006. {
  1007. rng_ = rng;
  1008. }
  1010. double PackMimeHTTPNumPagesRandomVariable::value(void)
  1011. {
  1012. double pages = 1;
  1013. if (rng_->rbernoulli(probability_) == 0) {
  1014. // multiple pages in this connection
  1015. pages = rng_->rweibull (shape_, scale_) + 1;
  1016. if (pages == 1) {
  1017. // should be at least 2 pages at this point
  1018. pages++;
  1019. }
  1020. }
  1021. return (pages);
  1022. }
  1024. const double PackMimeHTTPNumPagesRandomVariable::P_1PAGE = 0.82;      
  1025. const double PackMimeHTTPNumPagesRandomVariable::SHAPE_NPAGE = 1;
  1026. const double PackMimeHTTPNumPagesRandomVariable::SCALE_NPAGE = 0.417;
  1028. /*:::::::::::::::::::::: PackMimeHTTP SingleObj RanVar :::::::::::::::::::::::::*/
  1030. static class PackMimeHTTPSingleObjRandomVariableClass : public TclClass {
  1031. public:
  1032. PackMimeHTTPSingleObjRandomVariableClass() : 
  1033. TclClass("RandomVariable/PackMimeHTTPSingleObj"){}
  1034. TclObject* create(int argc, const char*const* argv) {
  1035. if (argc == 5) {
  1036. // probability
  1037. return(new PackMimeHTTPSingleObjRandomVariable 
  1038.        ((double) atof(argv[4])));
  1039. } else if (argc == 6) {
  1040. // probability, RNG
  1041. RNG* rng = (RNG*)TclObject::lookup(argv[5]);
  1042. return(new PackMimeHTTPSingleObjRandomVariable 
  1043.        ((double) atof(argv[4]), rng));
  1044. } else {
  1045. return(new PackMimeHTTPSingleObjRandomVariable());
  1046. }
  1047. }
  1048. } class_packmimesingleobjranvar;
  1051. PackMimeHTTPSingleObjRandomVariable::PackMimeHTTPSingleObjRandomVariable() :
  1052. probability_(P_1TRANSFER)
  1053. {
  1054. }
  1056. PackMimeHTTPSingleObjRandomVariable::PackMimeHTTPSingleObjRandomVariable(double prob) :
  1057. probability_(prob)
  1058. {
  1059. }
  1061. PackMimeHTTPSingleObjRandomVariable::PackMimeHTTPSingleObjRandomVariable(double prob, 
  1062.        RNG* rng) :
  1063. probability_(prob)
  1064. {
  1065. rng_ = rng;
  1066. }
  1068. double PackMimeHTTPSingleObjRandomVariable::value(void)
  1069. {
  1070. return (rng_->rbernoulli(probability_));
  1071. }
  1073. const double PackMimeHTTPSingleObjRandomVariable::P_1TRANSFER = 0.69; 
  1075. /*:::::::::::::::::::::: PackMimeHTTP ObjsPerPage RanVar :::::::::::::::::::::::::*/
  1077. static class PackMimeHTTPObjsPerPageRandomVariableClass : public TclClass {
  1078. public:
  1079. PackMimeHTTPObjsPerPageRandomVariableClass() : 
  1080. TclClass("RandomVariable/PackMimeHTTPObjsPerPage"){}
  1081. TclObject* create(int argc, const char*const* argv) {
  1082. if (argc == 6) {
  1083. // shape, scale
  1084. return(new PackMimeHTTPObjsPerPageRandomVariable 
  1085.        ((double) atof(argv[4]), (double) atof(argv[5])));
  1086. } else if (argc == 7) {
  1087. // shape, scale, RNG
  1088. RNG* rng = (RNG*)TclObject::lookup(argv[6]);
  1089. return(new PackMimeHTTPObjsPerPageRandomVariable 
  1090.        ((double) atof(argv[4]), (double) atof(argv[5]), rng));
  1091. } else {
  1092. return(new PackMimeHTTPObjsPerPageRandomVariable());
  1093. }
  1094. }
  1095. } class_packmimeobjsperpageranvar;
  1098. PackMimeHTTPObjsPerPageRandomVariable::PackMimeHTTPObjsPerPageRandomVariable() :
  1099. shape_(SHAPE_NTRANSFER), scale_(SCALE_NTRANSFER)
  1100. {
  1101. }
  1103. PackMimeHTTPObjsPerPageRandomVariable::PackMimeHTTPObjsPerPageRandomVariable(double shape,
  1104.        double scale) :
  1105. shape_(shape), scale_(scale)
  1106. {
  1107. }
  1109. PackMimeHTTPObjsPerPageRandomVariable::PackMimeHTTPObjsPerPageRandomVariable(double shape,
  1110.        double scale,
  1111.        RNG* rng) :
  1112. shape_(shape), scale_(scale)
  1113. {
  1114. rng_ = rng;
  1115. }
  1117. double PackMimeHTTPObjsPerPageRandomVariable::value(void)
  1118. {
  1119. return (rng_->rweibull (shape_, scale_) + 1);
  1120. }
  1122. const double PackMimeHTTPObjsPerPageRandomVariable::SHAPE_NTRANSFER = 1; 
  1123. const double PackMimeHTTPObjsPerPageRandomVariable::SCALE_NTRANSFER = 1.578;
  1125. /*:::::::::::::::::::::: PackMimeHTTP TimeBtwnPages RanVar :::::::::::::::::::::::::*/
  1127. static class PackMimeHTTPTimeBtwnPagesRandomVariableClass : public TclClass {
  1128. public:
  1129. PackMimeHTTPTimeBtwnPagesRandomVariableClass() : 
  1130. TclClass("RandomVariable/PackMimeHTTPTimeBtwnPages"){}
  1131. TclObject* create(int argc, const char*const* argv) {
  1132. if (argc == 5) {
  1133. // rng
  1134. RNG* rng = (RNG*)TclObject::lookup(argv[4]);
  1135. return(new PackMimeHTTPTimeBtwnPagesRandomVariable(rng));
  1136. } else {
  1137. return(new PackMimeHTTPTimeBtwnPagesRandomVariable());
  1138. }
  1139. }
  1140. } class_packmimetimebtwnpagesranvar;
  1143. PackMimeHTTPTimeBtwnPagesRandomVariable::PackMimeHTTPTimeBtwnPagesRandomVariable()
  1144. {
  1145. loc_b_ = rng_->rnorm() * sqrt(V_LOC_B) + M_LOC_B;
  1146. scale2_b_ = rng_->rgamma(SHAPE_SCALE2_B, 1/RATE_SCALE2_B);
  1147. }
  1149. PackMimeHTTPTimeBtwnPagesRandomVariable::PackMimeHTTPTimeBtwnPagesRandomVariable(RNG* rng)
  1150. {
  1151. rng_ = rng;
  1152. loc_b_ = rng_->rnorm() * sqrt(V_LOC_B) + M_LOC_B;
  1153. scale2_b_ = rng_->rgamma(SHAPE_SCALE2_B, 1/RATE_SCALE2_B);
  1154. }
  1156. double PackMimeHTTPTimeBtwnPagesRandomVariable::value(void)
  1157. {
  1158. return (pow (2.0, loc_b_ + sqrt(scale2_b_) * rng_->rnorm() * sqrt(V_ERROR_B)));
  1159. }
  1161. const double PackMimeHTTPTimeBtwnPagesRandomVariable::M_LOC_B = 3.22; 
  1162. const double PackMimeHTTPTimeBtwnPagesRandomVariable::V_LOC_B = 0.73; 
  1163. const double PackMimeHTTPTimeBtwnPagesRandomVariable::SHAPE_SCALE2_B = 1.85;
  1164. const double PackMimeHTTPTimeBtwnPagesRandomVariable::RATE_SCALE2_B = 1.85; 
  1165. const double PackMimeHTTPTimeBtwnPagesRandomVariable::V_ERROR_B = 1.21; 
  1167. /*:::::::::::::::::::::: PackMimeHTTP TimeBtwnObjs RanVar :::::::::::::::::::::::::*/
  1169. static class PackMimeHTTPTimeBtwnObjsRandomVariableClass : public TclClass {
  1170. public:
  1171. PackMimeHTTPTimeBtwnObjsRandomVariableClass() : 
  1172. TclClass("RandomVariable/PackMimeHTTPTimeBtwnObjs"){}
  1173. TclObject* create(int argc, const char*const* argv) {
  1174. if (argc == 5) {
  1175. // rng
  1176. RNG* rng = (RNG*)TclObject::lookup(argv[4]);
  1177. return(new PackMimeHTTPTimeBtwnObjsRandomVariable(rng));
  1178. } else {
  1179. return(new PackMimeHTTPTimeBtwnObjsRandomVariable());
  1180. }
  1181. }
  1182. } class_packmimetimebtwnobjsranvar;
  1185. PackMimeHTTPTimeBtwnObjsRandomVariable::PackMimeHTTPTimeBtwnObjsRandomVariable()
  1186. {
  1187. loc_w_ = rng_->rnorm() * sqrt(V_LOC_W) + M_LOC_W;
  1188. scale2_w_ = rng_->rgamma(SHAPE_SCALE2_W, 1/RATE_SCALE2_W);
  1189. }
  1191. PackMimeHTTPTimeBtwnObjsRandomVariable::PackMimeHTTPTimeBtwnObjsRandomVariable(RNG* rng)
  1192. {
  1193. rng_ = rng;
  1194. loc_w_ = rng_->rnorm() * sqrt(V_LOC_W) + M_LOC_W;
  1195. scale2_w_ = rng_->rgamma(SHAPE_SCALE2_W, 1/RATE_SCALE2_W);
  1196. }
  1198. double PackMimeHTTPTimeBtwnObjsRandomVariable::value(void)
  1199. {
  1200. return (pow (2.0, loc_w_ + sqrt(scale2_w_) * rng_->rnorm() * sqrt(V_ERROR_W)));
  1201. }
  1203. const double PackMimeHTTPTimeBtwnObjsRandomVariable::M_LOC_W = -4.15; 
  1204. const double PackMimeHTTPTimeBtwnObjsRandomVariable::V_LOC_W = 3.12;  
  1205. const double PackMimeHTTPTimeBtwnObjsRandomVariable::SHAPE_SCALE2_W = 2.35;
  1206. const double PackMimeHTTPTimeBtwnObjsRandomVariable::RATE_SCALE2_W = 2.35; 
  1207. const double PackMimeHTTPTimeBtwnObjsRandomVariable::V_ERROR_W = 1.57; 
  1209. /*:::::::::::::::::::::: PackMimeHTTP ServerDelay RanVar :::::::::::::::::::::::::*/
  1211. static class PackMimeHTTPServerDelayRandomVariableClass : public TclClass {
  1212. public:
  1213. PackMimeHTTPServerDelayRandomVariableClass() : 
  1214. TclClass("RandomVariable/PackMimeHTTPServerDelay"){}
  1215. TclObject* create(int argc, const char*const* argv) {
  1216. if (argc == 6) {
  1217. // shape, scale
  1218. return(new PackMimeHTTPServerDelayRandomVariable 
  1219.        ((double) atof(argv[4]), (double) atof(argv[5])));
  1220. } else if (argc == 7) {
  1221. // shape, scale, RNG
  1222. RNG* rng = (RNG*)TclObject::lookup(argv[6]);
  1223. return(new PackMimeHTTPServerDelayRandomVariable 
  1224.        ((double) atof(argv[4]), (double) atof(argv[5]), rng));
  1225. } else {
  1226. return(new PackMimeHTTPServerDelayRandomVariable());
  1227. }
  1228. }
  1229. } class_packmimeserverdelayranvar;
  1232. PackMimeHTTPServerDelayRandomVariable::PackMimeHTTPServerDelayRandomVariable() : 
  1233. shape_(SERVER_DELAY_SHAPE), scale_(SERVER_DELAY_SCALE), const_(1), mean_(0)
  1234. {
  1235. }
  1237. PackMimeHTTPServerDelayRandomVariable::PackMimeHTTPServerDelayRandomVariable(double shape,
  1238.      double scale) :
  1239. shape_(shape), scale_(scale), const_(1), mean_(0)
  1240. {
  1241. }
  1243. PackMimeHTTPServerDelayRandomVariable::PackMimeHTTPServerDelayRandomVariable(double shape,
  1244.      double scale,
  1245.      RNG* rng) :
  1246. shape_(shape), scale_(scale), const_(1), mean_(0)
  1247. {
  1248. rng_ = rng;
  1249. }
  1251. double PackMimeHTTPServerDelayRandomVariable::value(void)
  1252. {
  1253. /*
  1254.  *  sample from Weibull distribution.
  1255.  *  delay is 1/sample, with a max delay of 0.1 sec
  1256.  */
  1257. double val = rng_->rweibull(shape_, scale_);
  1259. if (val < 10) {
  1260. val = 10;
  1261. }
  1263. // adjust by const_ and mean_ (by default, this does nothing)
  1264. if (const_ == 0) {
  1265. const_ = mean_ / SERVER_DELAY_DIV;
  1266. }
  1267. val = val / const_;
  1269. return (1 / val);  // delay in seconds
  1270. }
  1272. const double PackMimeHTTPServerDelayRandomVariable::SERVER_DELAY_SHAPE = 0.63;
  1273. const double PackMimeHTTPServerDelayRandomVariable::SERVER_DELAY_SCALE = 305;
  1274. const double PackMimeHTTPServerDelayRandomVariable::SERVER_DELAY_DIV = 0.0059;