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
30NS_LOG_COMPONENT_DEFINE ("ThreeGppHttpVariables");
31
32namespace ns3 {
33
34
35NS_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
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.",
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.",
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)),
155
156 // PARSING TIME
157 .AddAttribute ("ParsingTimeMean",
158 "The mean of parsing time.",
159 TimeValue (MilliSeconds (130)),
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
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
204{
205 return m_requestSizeRng->GetInteger ();
206}
207
208
209Time
211{
213}
214
215
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
243Time
245{
247}
248
249
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
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
310Time
312{
313 return Seconds (m_readingTimeRng->GetValue ());
314}
315
316
317Time
319{
320 return Seconds (m_parsingTimeRng->GetValue ());
321}
322
323
324int64_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
342void
344{
345 NS_LOG_FUNCTION (this);
348}
349
350// SETTER METHODS /////////////////////////////////////////////////////////////
351
352
353void
355{
356 NS_LOG_FUNCTION (this << constant);
357 m_requestSizeRng->SetAttribute ("Constant",
358 DoubleValue (static_cast<double> (constant)));
359}
360
361
362void
364{
365 NS_LOG_FUNCTION (this << constant.As (Time::S));
367 DoubleValue (constant.GetSeconds ()));
368}
369
370void
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
384void
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
398void
400{
401 NS_LOG_FUNCTION (this << mean);
402 NS_ASSERT_MSG (mean > 0, "Mean must be greater than zero.");
404
405 if (IsInitialized ())
406 {
408 }
409}
410
411
412void
414{
415 NS_LOG_FUNCTION (this << stdDev);
416 m_mainObjectSizeStdDev = stdDev;
417
418 if (IsInitialized ())
419 {
421 }
422}
423
424
425void
427{
428 NS_LOG_FUNCTION (this << constant.As (Time::S));
430 DoubleValue (constant.GetSeconds ()));
431}
432
433
434void
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
448void
450{
451 NS_LOG_FUNCTION (this << stdDev);
453
454 if (IsInitialized ())
455 {
457 }
458}
459
460
461void
463{
464 NS_LOG_FUNCTION (this << max);
465 m_numOfEmbeddedObjectsRng->SetAttribute ("Bound",
466 DoubleValue (static_cast<double> (max)));
467}
468
469
470void
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
480void
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
490void
492{
493 NS_LOG_FUNCTION (this << mean.As (Time::S));
495}
496
497
498void
500{
501 NS_LOG_FUNCTION (this << mean.As (Time::S));
503}
504
505
506} // end of `namespace ns3`
#define max(a, b)
Definition: 80211b.c:43
double GetValue(double constant)
Get the next random value, as a double equal to the argument.
uint32_t GetInteger(uint32_t constant)
Get the next random value, as an integer equal to the argument.
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
double GetValue(double mean, double bound)
Get the next random value, as a double from the exponential distribution with the specified mean and ...
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
A base class which provides memory management and object aggregation.
Definition: object.h:88
bool IsInitialized(void) const
Check if the object has been initialized.
Definition: object.cc:208
void SetStream(int64_t stream)
Specifies the stream number for the RngStream.
void UpdateEmbeddedObjectMuAndSigma(void)
Upon and after object initialization, update random variable Mu and Sigma based on changes to attribu...
uint32_t m_mainObjectSizeMax
Upper bound parameter for m_mainObjectSizeRng;.
Ptr< ExponentialRandomVariable > m_parsingTimeRng
Random variable for determining the length of parsing time (in seconds).
uint32_t m_mainObjectSizeMin
Lower bound parameter for m_mainObjectSizeRng;.
Ptr< LogNormalRandomVariable > m_embeddedObjectSizeRng
Random variable for determining embedded object size (in bytes).
uint32_t m_numOfEmbeddedObjectsScale
Scale parameter for m_numOfEmbeddedObjectsRng.
void SetMainObjectGenerationDelay(Time constant)
static TypeId GetTypeId()
Returns the object TypeId.
Ptr< ConstantRandomVariable > m_requestSizeRng
Random variable for determining request size (in bytes).
void SetEmbeddedObjectGenerationDelay(Time constant)
uint32_t GetMtuSize()
Draws a random value of maximum transmission unit (MTU) size in bytes.
uint32_t m_mainObjectSizeMean
Mean parameter for m_mainObjectSizeRng;.
void UpdateMainObjectMuAndSigma(void)
Upon and after object initialization, update random variable Mu and Sigma based on changes to attribu...
Time GetEmbeddedObjectGenerationDelay()
Returns the constant length of time needed by an HTTP server to generate an embedded object.
void SetMainObjectSizeStdDev(uint32_t stdDev)
Ptr< LogNormalRandomVariable > m_mainObjectSizeRng
Random variable for determining main object size (in bytes).
uint32_t m_embeddedObjectSizeMax
Upper bound parameter for m_embeddedObjectSizeRng.
void SetNumOfEmbeddedObjectsScale(uint32_t scale)
Ptr< ExponentialRandomVariable > m_readingTimeRng
Random variable for determining the length of reading time (in seconds).
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Ptr< ConstantRandomVariable > m_mainObjectGenerationDelayRng
Random variable for determining the delay needed to generate a main object (in seconds).
void DoInitialize(void)
Initialize() implementation.
Time GetReadingTime()
Draws a random length of time which is spent by a hypothetical human user (HTTP client) to read a web...
Time GetMainObjectGenerationDelay()
Returns the constant length of time needed by an HTTP server to generate a main object.
uint32_t GetRequestSize()
Returns the constant HTTP 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_mainObjectSizeStdDev
Standard deviation parameter for m_mainObjectSizeRng;.
Ptr< ParetoRandomVariable > m_numOfEmbeddedObjectsRng
Random variable for determining the number of embedded objects.
void SetEmbeddedObjectSizeMean(uint32_t mean)
uint32_t GetEmbeddedObjectSize()
Draws a random embedded object size (in bytes) to be sent by an HTTP server.
void SetEmbeddedObjectSizeStdDev(uint32_t stdDev)
void SetNumOfEmbeddedObjectsMax(uint32_t max)
double m_highMtuProbability
High MTU size probability.
uint32_t m_embeddedObjectSizeMean
Mean parameter for m_embeddedObjectSizeRng.
uint32_t m_embeddedObjectSizeStdDev
Standard deviation parameter for m_embeddedObjectSizeRng.
void SetNumOfEmbeddedObjectsShape(double shape)
uint32_t m_highMtu
Higher MTU size.
uint32_t GetNumOfEmbeddedObjects()
Draws a random integer indicating the number of embedded objects in a main object.
uint32_t m_embeddedObjectSizeMin
Lower bound parameter for m_embeddedObjectSizeRng.
Ptr< ConstantRandomVariable > m_embeddedObjectGenerationDelayRng
Random variable for determining the delay needed to generate an embedded object (in seconds).
void SetRequestSize(uint32_t constant)
ThreeGppHttpVariables()
Create a new instance with default configuration of random distributions.
Ptr< UniformRandomVariable > m_mtuSizeRng
Random variable for determining MTU size (in bytes).
Time GetParsingTime()
Draws a random length of time which simulate the small delay caused by HTTP client looking for any em...
uint32_t m_lowMtu
Lower MTU size.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:379
@ S
second
Definition: nstime.h:114
TimeWithUnit As(const enum Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition: time.cc:418
AttributeValue implementation for Time.
Definition: nstime.h:1308
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
Hold an unsigned integer type.
Definition: uinteger.h:44
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
#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
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Definition: double.h:42
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1309
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1252
log2() macro definition; to deal with Bug 1467.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:522