OLD | NEW |
(Empty) | |
| 1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ |
| 2 /* |
| 3 * Copyright (c) 2013 Magister Solutions |
| 4 * |
| 5 * This program is free software; you can redistribute it and/or modify |
| 6 * it under the terms of the GNU General Public License version 2 as |
| 7 * published by the Free Software Foundation; |
| 8 * |
| 9 * This program is distributed in the hope that it will be useful, |
| 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 * GNU General Public License for more details. |
| 13 * |
| 14 * You should have received a copy of the GNU General Public License |
| 15 * along with this program; if not, write to the Free Software |
| 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 17 * |
| 18 * Author: Budiarto Herman <budiarto.herman@magister.fi> |
| 19 * |
| 20 */ |
| 21 |
| 22 #include "three-gpp-http-variables.h" |
| 23 |
| 24 #include <ns3/log.h> |
| 25 #include <ns3/uinteger.h> |
| 26 #include <ns3/double.h> |
| 27 #include <math.h> |
| 28 |
| 29 |
| 30 NS_LOG_COMPONENT_DEFINE ("ThreeGppHttpVariables"); |
| 31 |
| 32 namespace ns3 { |
| 33 |
| 34 |
| 35 NS_OBJECT_ENSURE_REGISTERED (ThreeGppHttpVariables); |
| 36 |
| 37 |
| 38 ThreeGppHttpVariables::ThreeGppHttpVariables () |
| 39 { |
| 40 NS_LOG_FUNCTION (this); |
| 41 m_mtuSizeRng = CreateObject<UniformRandomVariable> (); |
| 42 m_requestSizeRng = CreateObject<ConstantRandomVariable> (); |
| 43 m_mainObjectGenerationDelayRng = CreateObject<ConstantRandomVariable> (); |
| 44 m_mainObjectSizeRng = CreateObject<LogNormalRandomVariable> (); |
| 45 m_embeddedObjectGenerationDelayRng = CreateObject<ConstantRandomVariable> (); |
| 46 m_embeddedObjectSizeRng = CreateObject<LogNormalRandomVariable> (); |
| 47 m_numOfEmbeddedObjectsRng = CreateObject<ParetoRandomVariable> (); |
| 48 m_readingTimeRng = CreateObject<ExponentialRandomVariable> (); |
| 49 m_parsingTimeRng = CreateObject<ExponentialRandomVariable> (); |
| 50 } |
| 51 |
| 52 |
| 53 // static |
| 54 TypeId |
| 55 ThreeGppHttpVariables::GetTypeId () |
| 56 { |
| 57 static TypeId tid = TypeId ("ns3::ThreeGppHttpVariables") |
| 58 .SetParent<Object> () |
| 59 .AddConstructor<ThreeGppHttpVariables> () |
| 60 |
| 61 // REQUEST SIZE |
| 62 .AddAttribute ("RequestSize", |
| 63 "The constant size of HTTP request packet (in bytes).", |
| 64 UintegerValue (328), |
| 65 MakeUintegerAccessor (&ThreeGppHttpVariables::SetRequestSize)
, |
| 66 MakeUintegerChecker<uint32_t> ()) |
| 67 |
| 68 // MAIN OBJECT GENERATION DELAY |
| 69 .AddAttribute ("MainObjectGenerationDelay", |
| 70 "The constant time needed by HTTP server " |
| 71 "to generate a main object as a response.", |
| 72 TimeValue (MilliSeconds (0)), |
| 73 MakeTimeAccessor (&ThreeGppHttpVariables::SetMainObjectGenera
tionDelay), |
| 74 MakeTimeChecker ()) |
| 75 |
| 76 // MAIN OBJECT SIZE |
| 77 .AddAttribute ("MainObjectSizeMean", |
| 78 "The mean of main object sizes (in bytes).", |
| 79 UintegerValue (10710), |
| 80 MakeUintegerAccessor (&ThreeGppHttpVariables::SetMainObjectSi
zeMean), |
| 81 MakeUintegerChecker<uint32_t> ()) |
| 82 .AddAttribute ("MainObjectSizeStdDev", |
| 83 "The standard deviation of main object sizes (in bytes).", |
| 84 UintegerValue (25032), |
| 85 MakeUintegerAccessor (&ThreeGppHttpVariables::SetMainObjectSi
zeStdDev), |
| 86 MakeUintegerChecker<uint32_t> ()) |
| 87 .AddAttribute ("MainObjectSizeMin", |
| 88 "The minimum value of main object sizes (in bytes).", |
| 89 UintegerValue (100), |
| 90 MakeUintegerAccessor (&ThreeGppHttpVariables::m_mainObjectSiz
eMin), |
| 91 MakeUintegerChecker<uint32_t> (22)) |
| 92 .AddAttribute ("MainObjectSizeMax", |
| 93 "The maximum value of main object sizes (in bytes).", |
| 94 UintegerValue (2000000), // 2 MB |
| 95 MakeUintegerAccessor (&ThreeGppHttpVariables::m_mainObjectSiz
eMax), |
| 96 MakeUintegerChecker<uint32_t> ()) |
| 97 |
| 98 // EMBEDDED OBJECT GENERATION DELAY |
| 99 .AddAttribute ("EmbeddedObjectGenerationDelay", |
| 100 "The constant time needed by HTTP server " |
| 101 "to generate an embedded object as a response.", |
| 102 TimeValue (MilliSeconds (0)), |
| 103 MakeTimeAccessor (&ThreeGppHttpVariables::SetEmbeddedObjectGe
nerationDelay), |
| 104 MakeTimeChecker ()) |
| 105 |
| 106 // EMBEDDED OBJECT SIZE |
| 107 .AddAttribute ("EmbeddedObjectSizeMean", |
| 108 "The mean of embedded object sizes (in bytes).", |
| 109 UintegerValue (7758), |
| 110 MakeUintegerAccessor (&ThreeGppHttpVariables::SetEmbeddedObje
ctSizeMean), |
| 111 MakeUintegerChecker<uint32_t> ()) |
| 112 .AddAttribute ("EmbeddedObjectSizeStdDev", |
| 113 "The standard deviation of embedded object sizes (in bytes)."
, |
| 114 UintegerValue (126168), |
| 115 MakeUintegerAccessor (&ThreeGppHttpVariables::SetEmbeddedObje
ctSizeStdDev), |
| 116 MakeUintegerChecker<uint32_t> ()) |
| 117 .AddAttribute ("EmbeddedObjectSizeMin", |
| 118 "The minimum value of embedded object sizes (in bytes).", |
| 119 UintegerValue (50), |
| 120 MakeUintegerAccessor (&ThreeGppHttpVariables::m_embeddedObjec
tSizeMin), |
| 121 MakeUintegerChecker<uint32_t> (22)) |
| 122 .AddAttribute ("EmbeddedObjectSizeMax", |
| 123 "The maximum value of embedded object sizes (in bytes).", |
| 124 UintegerValue (2000000), // 2 MB |
| 125 MakeUintegerAccessor (&ThreeGppHttpVariables::m_embeddedObjec
tSizeMax), |
| 126 MakeUintegerChecker<uint32_t> ()) |
| 127 |
| 128 // NUMBER OF EMBEDDED OBJECTS PER PAGE |
| 129 .AddAttribute ("NumOfEmbeddedObjectsMax", |
| 130 "The upper bound parameter of Pareto distribution for " |
| 131 "the number of embedded objects per web page. The actual " |
| 132 "maximum value is this value subtracted by the scale paramete
r.", |
| 133 UintegerValue (55), |
| 134 MakeUintegerAccessor (&ThreeGppHttpVariables::SetNumOfEmbedde
dObjectsMax), |
| 135 MakeUintegerChecker<uint32_t> ()) |
| 136 .AddAttribute ("NumOfEmbeddedObjectsShape", |
| 137 "The shape parameter of Pareto distribution for " |
| 138 "the number of embedded objects per web page.", |
| 139 DoubleValue (1.1), |
| 140 MakeDoubleAccessor (&ThreeGppHttpVariables::SetNumOfEmbeddedO
bjectsShape), |
| 141 MakeDoubleChecker<double> ()) |
| 142 .AddAttribute ("NumOfEmbeddedObjectsScale", |
| 143 "The scale parameter of Pareto distribution for " |
| 144 "the number of embedded objects per web page.", |
| 145 UintegerValue (2), |
| 146 MakeUintegerAccessor (&ThreeGppHttpVariables::SetNumOfEmbedde
dObjectsScale), |
| 147 MakeUintegerChecker<uint32_t> ()) |
| 148 |
| 149 // READING TIME |
| 150 .AddAttribute ("ReadingTimeMean", |
| 151 "The mean of reading time.", |
| 152 TimeValue (Seconds (30)), |
| 153 MakeTimeAccessor (&ThreeGppHttpVariables::SetReadingTimeMean)
, |
| 154 MakeTimeChecker ()) |
| 155 |
| 156 // PARSING TIME |
| 157 .AddAttribute ("ParsingTimeMean", |
| 158 "The mean of parsing time.", |
| 159 TimeValue (MilliSeconds (130)), |
| 160 MakeTimeAccessor (&ThreeGppHttpVariables::SetParsingTimeMean)
, |
| 161 MakeTimeChecker ()) |
| 162 |
| 163 // MTU SIZE |
| 164 .AddAttribute ("LowMtuSize", |
| 165 "The lower MTU size.", |
| 166 UintegerValue (536), |
| 167 MakeUintegerAccessor (&ThreeGppHttpVariables::m_lowMtu), |
| 168 MakeUintegerChecker<uint32_t> (0)) |
| 169 .AddAttribute ("HighMtuSize", |
| 170 "The higher MTU size.", |
| 171 UintegerValue (1460), |
| 172 MakeUintegerAccessor (&ThreeGppHttpVariables::m_highMtu), |
| 173 MakeUintegerChecker<uint32_t> (0)) |
| 174 .AddAttribute ("HighMtuProbability", |
| 175 "The probability that higher MTU size is used.", |
| 176 DoubleValue (0.76), |
| 177 MakeDoubleAccessor (&ThreeGppHttpVariables::m_highMtuProbabil
ity), |
| 178 MakeDoubleChecker<double> (0, 1)) |
| 179 ; |
| 180 return tid; |
| 181 |
| 182 } |
| 183 |
| 184 |
| 185 uint32_t |
| 186 ThreeGppHttpVariables::GetMtuSize () |
| 187 { |
| 188 const double r = m_mtuSizeRng->GetValue (); |
| 189 NS_ASSERT (r >= 0.0); |
| 190 NS_ASSERT (r < 1.0); |
| 191 if (r < m_highMtuProbability) |
| 192 { |
| 193 return m_highMtu; // 1500 bytes if including TCP header. |
| 194 } |
| 195 else |
| 196 { |
| 197 return m_lowMtu; // 576 bytes if including TCP header. |
| 198 } |
| 199 } |
| 200 |
| 201 |
| 202 uint32_t |
| 203 ThreeGppHttpVariables::GetRequestSize () |
| 204 { |
| 205 return m_requestSizeRng->GetInteger (); |
| 206 } |
| 207 |
| 208 |
| 209 Time |
| 210 ThreeGppHttpVariables::GetMainObjectGenerationDelay () |
| 211 { |
| 212 return Seconds (m_mainObjectGenerationDelayRng->GetValue ()); |
| 213 } |
| 214 |
| 215 |
| 216 uint32_t |
| 217 ThreeGppHttpVariables::GetMainObjectSize () |
| 218 { |
| 219 // Validate parameters. |
| 220 if (m_mainObjectSizeMax <= m_mainObjectSizeMin) |
| 221 { |
| 222 NS_FATAL_ERROR ("`MainObjectSizeMax` attribute " |
| 223 << " must be greater than" |
| 224 << " the `MainObjectSizeMin` attribute."); |
| 225 } |
| 226 |
| 227 /* |
| 228 * Repeatedly draw one new random value until it falls in the interval |
| 229 * [min, max). The previous validation ensures this process does not loop |
| 230 * indefinitely. |
| 231 */ |
| 232 uint32_t value; |
| 233 do |
| 234 { |
| 235 value = m_mainObjectSizeRng->GetInteger (); |
| 236 } |
| 237 while ((value < m_mainObjectSizeMin) || (value >= m_mainObjectSizeMax)); |
| 238 |
| 239 return value; |
| 240 } |
| 241 |
| 242 |
| 243 Time |
| 244 ThreeGppHttpVariables::GetEmbeddedObjectGenerationDelay () |
| 245 { |
| 246 return Seconds (m_embeddedObjectGenerationDelayRng->GetValue ()); |
| 247 } |
| 248 |
| 249 |
| 250 uint32_t |
| 251 ThreeGppHttpVariables::GetEmbeddedObjectSize () |
| 252 { |
| 253 // Validate parameters. |
| 254 if (m_embeddedObjectSizeMax <= m_embeddedObjectSizeMin) |
| 255 { |
| 256 NS_FATAL_ERROR ("`EmbeddedObjectSizeMax` attribute " |
| 257 << " must be greater than" |
| 258 << " the `EmbeddedObjectSizeMin` attribute."); |
| 259 } |
| 260 |
| 261 /* |
| 262 * Repeatedly draw one new random value until it falls in the interval |
| 263 * [min, max). The previous validation ensures this process does not loop |
| 264 * indefinitely. |
| 265 */ |
| 266 uint32_t value; |
| 267 do |
| 268 { |
| 269 value = m_embeddedObjectSizeRng->GetInteger (); |
| 270 } |
| 271 while ((value < m_embeddedObjectSizeMin) || (value >= m_embeddedObjectSizeMax)
); |
| 272 |
| 273 return value; |
| 274 } |
| 275 |
| 276 |
| 277 uint32_t |
| 278 ThreeGppHttpVariables::GetNumOfEmbeddedObjects () |
| 279 { |
| 280 // Validate parameters. |
| 281 const uint32_t upperBound = |
| 282 static_cast<uint32_t> (m_numOfEmbeddedObjectsRng->GetBound ()); |
| 283 if (upperBound <= m_numOfEmbeddedObjectsScale) |
| 284 { |
| 285 NS_FATAL_ERROR ("`NumOfEmbeddedObjectsMax` attribute " |
| 286 << " must be greater than" |
| 287 << " the `NumOfEmbeddedObjectsScale` attribute."); |
| 288 } |
| 289 |
| 290 /* |
| 291 * Repeatedly draw one new random value until it falls in the interval |
| 292 * [scale, upperBound). The previous validation ensures this process does |
| 293 * not loop indefinitely. |
| 294 */ |
| 295 uint32_t value; |
| 296 do |
| 297 { |
| 298 value = m_numOfEmbeddedObjectsRng->GetInteger (); |
| 299 } |
| 300 while ((value < m_numOfEmbeddedObjectsScale) || (value >= upperBound)); |
| 301 |
| 302 /* |
| 303 * Normalize the random value with the scale parameter. The returned value |
| 304 * shall now be within the interval [0, (upperBound - scale)). |
| 305 */ |
| 306 return (value - m_numOfEmbeddedObjectsScale); |
| 307 } |
| 308 |
| 309 |
| 310 Time |
| 311 ThreeGppHttpVariables::GetReadingTime () |
| 312 { |
| 313 return Seconds (m_readingTimeRng->GetValue ()); |
| 314 } |
| 315 |
| 316 |
| 317 Time |
| 318 ThreeGppHttpVariables::GetParsingTime () |
| 319 { |
| 320 return Seconds (m_parsingTimeRng->GetValue ()); |
| 321 } |
| 322 |
| 323 |
| 324 int64_t |
| 325 ThreeGppHttpVariables::AssignStreams (int64_t stream) |
| 326 { |
| 327 NS_LOG_FUNCTION (this << stream); |
| 328 |
| 329 m_mtuSizeRng->SetStream (stream); |
| 330 m_requestSizeRng->SetStream (stream + 1); |
| 331 m_mainObjectGenerationDelayRng->SetStream (stream + 2); |
| 332 m_mainObjectSizeRng->SetStream (stream + 3); |
| 333 m_embeddedObjectGenerationDelayRng->SetStream (stream + 4); |
| 334 m_embeddedObjectSizeRng->SetStream (stream + 5); |
| 335 m_numOfEmbeddedObjectsRng->SetStream (stream + 6); |
| 336 m_readingTimeRng->SetStream (stream + 7); |
| 337 m_parsingTimeRng->SetStream (stream + 8); |
| 338 |
| 339 return 9; |
| 340 } |
| 341 |
| 342 |
| 343 // SETTER METHODS ///////////////////////////////////////////////////////////// |
| 344 |
| 345 |
| 346 void |
| 347 ThreeGppHttpVariables::SetRequestSize (uint32_t constant) |
| 348 { |
| 349 NS_LOG_FUNCTION (this << constant); |
| 350 m_requestSizeRng->SetAttribute ("Constant", |
| 351 DoubleValue (static_cast<double> (constant))); |
| 352 } |
| 353 |
| 354 |
| 355 void |
| 356 ThreeGppHttpVariables::SetMainObjectGenerationDelay (Time constant) |
| 357 { |
| 358 NS_LOG_FUNCTION (this << constant.GetSeconds ()); |
| 359 m_mainObjectGenerationDelayRng->SetAttribute ("Constant", |
| 360 DoubleValue (constant.GetSeconds
())); |
| 361 } |
| 362 |
| 363 |
| 364 void |
| 365 ThreeGppHttpVariables::SetMainObjectSizeMean (uint32_t mean) |
| 366 { |
| 367 NS_LOG_FUNCTION (this << mean); |
| 368 NS_ASSERT_MSG (mean > 0, "Mean must be greater than zero."); |
| 369 m_mainObjectSizeMean = mean; |
| 370 |
| 371 // Update Mu and Sigma. |
| 372 const double a1 = std::pow (m_mainObjectSizeStdDev, 2.0); |
| 373 const double a2 = std::pow (m_mainObjectSizeMean, 2.0); |
| 374 const double a = std::log (1.0 + (a1 / a2)); |
| 375 const double mu = std::log (m_mainObjectSizeMean) - (0.5 * a); |
| 376 const double sigma = std::sqrt (a); |
| 377 NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << "."); |
| 378 m_mainObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu)); |
| 379 m_mainObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma)); |
| 380 } |
| 381 |
| 382 |
| 383 void |
| 384 ThreeGppHttpVariables::SetMainObjectSizeStdDev (uint32_t stdDev) |
| 385 { |
| 386 NS_LOG_FUNCTION (this << stdDev); |
| 387 m_mainObjectSizeStdDev = stdDev; |
| 388 |
| 389 // Update Mu and Sigma. Same piece of code as in SetMainObjectSizeMean(). |
| 390 const double a1 = std::pow (m_mainObjectSizeStdDev, 2.0); |
| 391 const double a2 = std::pow (m_mainObjectSizeMean, 2.0); |
| 392 const double a = std::log (1.0 + (a1 / a2)); |
| 393 const double mu = std::log (m_mainObjectSizeMean) - (0.5 * a); |
| 394 const double sigma = std::sqrt (a); |
| 395 NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << "."); |
| 396 m_mainObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu)); |
| 397 m_mainObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma)); |
| 398 } |
| 399 |
| 400 |
| 401 void |
| 402 ThreeGppHttpVariables::SetEmbeddedObjectGenerationDelay (Time constant) |
| 403 { |
| 404 NS_LOG_FUNCTION (this << constant.GetSeconds ()); |
| 405 m_embeddedObjectGenerationDelayRng->SetAttribute ("Constant", |
| 406 DoubleValue (constant.GetSec
onds ())); |
| 407 } |
| 408 |
| 409 |
| 410 void |
| 411 ThreeGppHttpVariables::SetEmbeddedObjectSizeMean (uint32_t mean) |
| 412 { |
| 413 NS_LOG_FUNCTION (this << mean); |
| 414 NS_ASSERT_MSG (mean > 0, "Mean must be greater than zero."); |
| 415 m_embeddedObjectSizeMean = mean; |
| 416 |
| 417 // Update Mu and Sigma. |
| 418 const double a1 = std::pow (m_embeddedObjectSizeStdDev, 2.0); |
| 419 const double a2 = std::pow (m_embeddedObjectSizeMean, 2.0); |
| 420 const double a = std::log (1.0 + (a1 / a2)); |
| 421 const double mu = std::log (m_embeddedObjectSizeMean) - (0.5 * a); |
| 422 const double sigma = std::sqrt (a); |
| 423 NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << "."); |
| 424 m_embeddedObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu)); |
| 425 m_embeddedObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma)); |
| 426 } |
| 427 |
| 428 |
| 429 void |
| 430 ThreeGppHttpVariables::SetEmbeddedObjectSizeStdDev (uint32_t stdDev) |
| 431 { |
| 432 NS_LOG_FUNCTION (this << stdDev); |
| 433 m_embeddedObjectSizeStdDev = stdDev; |
| 434 |
| 435 // Update Mu and Sigma. Same piece of code as in SetEmbeddedObjectSizeMean(). |
| 436 const double a1 = std::pow (m_embeddedObjectSizeStdDev, 2.0); |
| 437 const double a2 = std::pow (m_embeddedObjectSizeMean, 2.0); |
| 438 const double a = std::log (1.0 + (a1 / a2)); |
| 439 const double mu = std::log (m_embeddedObjectSizeMean) - (0.5 * a); |
| 440 const double sigma = std::sqrt (a); |
| 441 NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << "."); |
| 442 m_embeddedObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu)); |
| 443 m_embeddedObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma)); |
| 444 } |
| 445 |
| 446 |
| 447 void |
| 448 ThreeGppHttpVariables::SetNumOfEmbeddedObjectsMax (uint32_t max) |
| 449 { |
| 450 NS_LOG_FUNCTION (this << max); |
| 451 m_numOfEmbeddedObjectsRng->SetAttribute ("Bound", |
| 452 DoubleValue (static_cast<double> (max
))); |
| 453 } |
| 454 |
| 455 |
| 456 void |
| 457 ThreeGppHttpVariables::SetNumOfEmbeddedObjectsShape (double shape) |
| 458 { |
| 459 NS_LOG_FUNCTION (this << shape); |
| 460 NS_ASSERT_MSG (std::fabs (shape - 1.0) > 0.000001, |
| 461 "Shape parameter must not equal to 1.0."); |
| 462 m_numOfEmbeddedObjectsRng->SetAttribute ("Shape", DoubleValue (shape)); |
| 463 |
| 464 // Mean is determined by shape and scale. We now update the mean. |
| 465 const double mean = (shape * m_numOfEmbeddedObjectsScale) / (shape - 1.0); |
| 466 NS_LOG_DEBUG (this << " Mean= " << mean << "."); |
| 467 m_numOfEmbeddedObjectsRng->SetAttribute ("Mean", DoubleValue (mean)); |
| 468 } |
| 469 |
| 470 |
| 471 void |
| 472 ThreeGppHttpVariables::SetNumOfEmbeddedObjectsScale (uint32_t scale) |
| 473 { |
| 474 NS_LOG_FUNCTION (this << scale); |
| 475 NS_ASSERT_MSG (scale > 0, "Scale parameter must be greater than zero."); |
| 476 m_numOfEmbeddedObjectsScale = scale; |
| 477 |
| 478 // Mean is determined by shape and scale. We now update the mean. |
| 479 const double shape = m_numOfEmbeddedObjectsRng->GetShape (); |
| 480 const double mean = (shape * static_cast<double> (scale)) / (shape - 1.0); |
| 481 NS_LOG_DEBUG (this << " Mean= " << mean << "."); |
| 482 m_numOfEmbeddedObjectsRng->SetAttribute ("Mean", DoubleValue (mean)); |
| 483 } |
| 484 |
| 485 |
| 486 void |
| 487 ThreeGppHttpVariables::SetReadingTimeMean (Time mean) |
| 488 { |
| 489 NS_LOG_FUNCTION (this << mean.GetSeconds ()); |
| 490 m_readingTimeRng->SetAttribute ("Mean", DoubleValue (mean.GetSeconds ())); |
| 491 } |
| 492 |
| 493 |
| 494 void |
| 495 ThreeGppHttpVariables::SetParsingTimeMean (Time mean) |
| 496 { |
| 497 NS_LOG_FUNCTION (this << mean.GetSeconds ()); |
| 498 m_parsingTimeRng->SetAttribute ("Mean", DoubleValue (mean.GetSeconds ())); |
| 499 } |
| 500 |
| 501 |
| 502 } // end of `namespace ns3` |
OLD | NEW |