A Discrete-Event Network Simulator
API
three-gpp-http-variables.cc
Go to the documentation of this file.
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 
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 
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
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),
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)),
74  MakeTimeChecker ())
75 
76  // MAIN OBJECT SIZE
77  .AddAttribute ("MainObjectSizeMean",
78  "The mean of main object sizes (in bytes).",
79  UintegerValue (10710),
81  MakeUintegerChecker<uint32_t> ())
82  .AddAttribute ("MainObjectSizeStdDev",
83  "The standard deviation of main object sizes (in bytes).",
84  UintegerValue (25032),
86  MakeUintegerChecker<uint32_t> ())
87  .AddAttribute ("MainObjectSizeMin",
88  "The minimum value of main object sizes (in bytes).",
89  UintegerValue (100),
91  MakeUintegerChecker<uint32_t> (22))
92  .AddAttribute ("MainObjectSizeMax",
93  "The maximum value of main object sizes (in bytes).",
94  UintegerValue (2000000), // 2 MB
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)),
104  MakeTimeChecker ())
105 
106  // EMBEDDED OBJECT SIZE
107  .AddAttribute ("EmbeddedObjectSizeMean",
108  "The mean of embedded object sizes (in bytes).",
109  UintegerValue (7758),
111  MakeUintegerChecker<uint32_t> ())
112  .AddAttribute ("EmbeddedObjectSizeStdDev",
113  "The standard deviation of embedded object sizes (in bytes).",
114  UintegerValue (126168),
116  MakeUintegerChecker<uint32_t> ())
117  .AddAttribute ("EmbeddedObjectSizeMin",
118  "The minimum value of embedded object sizes (in bytes).",
119  UintegerValue (50),
121  MakeUintegerChecker<uint32_t> (22))
122  .AddAttribute ("EmbeddedObjectSizeMax",
123  "The maximum value of embedded object sizes (in bytes).",
124  UintegerValue (2000000), // 2 MB
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 parameter.",
133  UintegerValue (55),
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),
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),
147  MakeUintegerChecker<uint32_t> ())
148 
149  // READING TIME
150  .AddAttribute ("ReadingTimeMean",
151  "The mean of reading time.",
152  TimeValue (Seconds (30)),
154  MakeTimeChecker ())
155 
156  // PARSING TIME
157  .AddAttribute ("ParsingTimeMean",
158  "The mean of parsing time.",
159  TimeValue (MilliSeconds (130)),
161  MakeTimeChecker ())
162 
163  // MTU SIZE
164  .AddAttribute ("LowMtuSize",
165  "The lower MTU size.",
166  UintegerValue (536),
168  MakeUintegerChecker<uint32_t> (0))
169  .AddAttribute ("HighMtuSize",
170  "The higher MTU size.",
171  UintegerValue (1460),
173  MakeUintegerChecker<uint32_t> (0))
174  .AddAttribute ("HighMtuProbability",
175  "The probability that higher MTU size is used.",
176  DoubleValue (0.76),
178  MakeDoubleChecker<double> (0, 1))
179  ;
180  return tid;
181 
182 }
183 
184 
185 uint32_t
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
204 {
205  return m_requestSizeRng->GetInteger ();
206 }
207 
208 
209 Time
211 {
213 }
214 
215 
216 uint32_t
218 {
219  // Validate parameters.
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
245 {
247 }
248 
249 
250 uint32_t
252 {
253  // Validate parameters.
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
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
312 {
313  return Seconds (m_readingTimeRng->GetValue ());
314 }
315 
316 
317 Time
319 {
320  return Seconds (m_parsingTimeRng->GetValue ());
321 }
322 
323 
324 int64_t
326 {
327  NS_LOG_FUNCTION (this << stream);
328 
329  m_mtuSizeRng->SetStream (stream);
330  m_requestSizeRng->SetStream (stream + 1);
332  m_mainObjectSizeRng->SetStream (stream + 3);
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 void
344 {
345  NS_LOG_FUNCTION (this);
348 }
349 
350 // SETTER METHODS /////////////////////////////////////////////////////////////
351 
352 
353 void
355 {
356  NS_LOG_FUNCTION (this << constant);
357  m_requestSizeRng->SetAttribute ("Constant",
358  DoubleValue (static_cast<double> (constant)));
359 }
360 
361 
362 void
364 {
365  NS_LOG_FUNCTION (this << constant.GetSeconds ());
367  DoubleValue (constant.GetSeconds ()));
368 }
369 
370 void
372 {
373  NS_LOG_FUNCTION (this);
374  const double a1 = std::pow (m_mainObjectSizeStdDev, 2.0);
375  const double a2 = std::pow (m_mainObjectSizeMean, 2.0);
376  const double a = std::log (1.0 + (a1 / a2));
377  const double mu = std::log (m_mainObjectSizeMean) - (0.5 * a);
378  const double sigma = std::sqrt (a);
379  NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << ".");
380  m_mainObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu));
381  m_mainObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma));
382 }
383 
384 void
386 {
387  NS_LOG_FUNCTION (this);
388  const double a1 = std::pow (m_embeddedObjectSizeStdDev, 2.0);
389  const double a2 = std::pow (m_embeddedObjectSizeMean, 2.0);
390  const double a = std::log (1.0 + (a1 / a2));
391  const double mu = std::log (m_embeddedObjectSizeMean) - (0.5 * a);
392  const double sigma = std::sqrt (a);
393  NS_LOG_DEBUG (this << " Mu= " << mu << " Sigma= " << sigma << ".");
394  m_embeddedObjectSizeRng->SetAttribute ("Mu", DoubleValue (mu));
395  m_embeddedObjectSizeRng->SetAttribute ("Sigma", DoubleValue (sigma));
396 }
397 
398 void
400 {
401  NS_LOG_FUNCTION (this << mean);
402  NS_ASSERT_MSG (mean > 0, "Mean must be greater than zero.");
403  m_mainObjectSizeMean = mean;
404 
405  if (IsInitialized ())
406  {
408  }
409 }
410 
411 
412 void
414 {
415  NS_LOG_FUNCTION (this << stdDev);
416  m_mainObjectSizeStdDev = stdDev;
417 
418  if (IsInitialized ())
419  {
421  }
422 }
423 
424 
425 void
427 {
428  NS_LOG_FUNCTION (this << constant.GetSeconds ());
430  DoubleValue (constant.GetSeconds ()));
431 }
432 
433 
434 void
436 {
437  NS_LOG_FUNCTION (this << mean);
438  NS_ASSERT_MSG (mean > 0, "Mean must be greater than zero.");
440 
441  if (IsInitialized ())
442  {
444  }
445 }
446 
447 
448 void
450 {
451  NS_LOG_FUNCTION (this << stdDev);
453 
454  if (IsInitialized ())
455  {
457  }
458 }
459 
460 
461 void
463 {
464  NS_LOG_FUNCTION (this << max);
465  m_numOfEmbeddedObjectsRng->SetAttribute ("Bound",
466  DoubleValue (static_cast<double> (max)));
467 }
468 
469 
470 void
472 {
473  NS_LOG_FUNCTION (this << shape);
474  NS_ASSERT_MSG (std::fabs (shape - 1.0) > 0.000001,
475  "Shape parameter must not equal to 1.0.");
476  m_numOfEmbeddedObjectsRng->SetAttribute ("Shape", DoubleValue (shape));
477 }
478 
479 
480 void
482 {
483  NS_LOG_FUNCTION (this << scale);
484  NS_ASSERT_MSG (scale > 0, "Scale parameter must be greater than zero.");
486  m_numOfEmbeddedObjectsRng->SetAttribute ("Scale", DoubleValue (scale));
487 }
488 
489 
490 void
492 {
493  NS_LOG_FUNCTION (this << mean.GetSeconds ());
495 }
496 
497 
498 void
500 {
501  NS_LOG_FUNCTION (this << mean.GetSeconds ());
503 }
504 
505 
506 } // end of `namespace ns3`
log2() macro definition; to deal with Bug 1467.
uint32_t m_mainObjectSizeMax
Upper bound parameter for m_mainObjectSizeRng;.
Time GetParsingTime()
Draws a random length of time which simulate the small delay caused by HTTP client looking for any em...
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
static TypeId GetTypeId()
Returns the object TypeId.
void SetNumOfEmbeddedObjectsShape(double shape)
double GetValue(double constant)
Get the next random value, as a double equal to the argument.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
void SetStream(int64_t stream)
Specifies the stream number for the RngStream.
uint32_t m_embeddedObjectSizeMax
Upper bound parameter for m_embeddedObjectSizeRng.
Ptr< ConstantRandomVariable > m_embeddedObjectGenerationDelayRng
Random variable for determining the delay needed to generate an embedded object (in seconds)...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
void SetMainObjectSizeStdDev(uint32_t stdDev)
uint32_t GetRequestSize()
Returns the constant HTTP request size in bytes.
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:361
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
bool IsInitialized(void) const
Check if the object has been initialized.
Definition: object.cc:208
ThreeGppHttpVariables()
Create a new instance with default configuration of random distributions.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1078
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
Time GetMainObjectGenerationDelay()
Returns the constant length of time needed by an HTTP server to generate a main object.
void SetNumOfEmbeddedObjectsScale(uint32_t scale)
void SetEmbeddedObjectSizeMean(uint32_t mean)
void UpdateEmbeddedObjectMuAndSigma(void)
Upon and after object initialization, update random variable Mu and Sigma based on changes to attribu...
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:449
double m_highMtuProbability
High MTU size probability.
void SetRequestSize(uint32_t constant)
void SetMainObjectGenerationDelay(Time constant)
uint32_t m_numOfEmbeddedObjectsScale
Scale parameter for m_numOfEmbeddedObjectsRng.
AttributeValue implementation for Time.
Definition: nstime.h:1132
uint32_t GetNumOfEmbeddedObjects()
Draws a random integer indicating the number of embedded objects in a main object.
uint32_t GetInteger(uint32_t constant)
Get the next random value, as an integer equal to the argument.
Hold an unsigned integer type.
Definition: uinteger.h:44
uint32_t m_highMtu
Higher MTU size.
Ptr< ConstantRandomVariable > m_requestSizeRng
Random variable for determining request size (in bytes).
uint32_t GetMainObjectSize()
Draws a random main object size (in bytes) to be sent by an HTTP server.
uint32_t m_embeddedObjectSizeMean
Mean parameter for m_embeddedObjectSizeRng.
void SetEmbeddedObjectGenerationDelay(Time constant)
Time GetEmbeddedObjectGenerationDelay()
Returns the constant length of time needed by an HTTP server to generate an embedded object...
uint32_t m_lowMtu
Lower MTU size.
uint32_t m_mainObjectSizeMean
Mean parameter for m_mainObjectSizeRng;.
Ptr< LogNormalRandomVariable > m_embeddedObjectSizeRng
Random variable for determining embedded object size (in bytes).
void DoInitialize(void)
Initialize() implementation.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< LogNormalRandomVariable > m_mainObjectSizeRng
Random variable for determining main object size (in bytes).
uint32_t GetEmbeddedObjectSize()
Draws a random embedded object size (in bytes) to be sent by an HTTP server.
uint32_t m_mainObjectSizeStdDev
Standard deviation parameter for m_mainObjectSizeRng;.
Ptr< ExponentialRandomVariable > m_readingTimeRng
Random variable for determining the length of reading time (in seconds).
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
Ptr< ConstantRandomVariable > m_mainObjectGenerationDelayRng
Random variable for determining the delay needed to generate a main object (in seconds).
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model...
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: nstime.h:1133
Ptr< ParetoRandomVariable > m_numOfEmbeddedObjectsRng
Random variable for determining the number of embedded objects.
Ptr< ExponentialRandomVariable > m_parsingTimeRng
Random variable for determining the length of parsing time (in seconds).
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: double.h:42
Time GetReadingTime()
Draws a random length of time which is spent by a hypothetical human user (HTTP client) to read a web...
double max(double x, double y)
uint32_t m_embeddedObjectSizeMin
Lower bound parameter for m_embeddedObjectSizeRng.
void UpdateMainObjectMuAndSigma(void)
Upon and after object initialization, update random variable Mu and Sigma based on changes to attribu...
uint32_t GetMtuSize()
Draws a random value of maximum transmission unit (MTU) size in bytes.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1070
double GetValue(double mean, double bound)
Get the next random value, as a double from the exponential distribution with the specified mean and ...
Ptr< UniformRandomVariable > m_mtuSizeRng
Random variable for determining MTU size (in bytes).
void SetNumOfEmbeddedObjectsMax(uint32_t max)
A base class which provides memory management and object aggregation.
Definition: object.h:87
uint32_t m_mainObjectSizeMin
Lower bound parameter for m_mainObjectSizeRng;.
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
uint32_t m_embeddedObjectSizeStdDev
Standard deviation parameter for m_embeddedObjectSizeRng.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:187
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: uinteger.h:45
a unique identifier for an interface.
Definition: type-id.h:58
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:923
void SetEmbeddedObjectSizeStdDev(uint32_t stdDev)