A Discrete-Event Network Simulator
Home
Tutorials ▼
English
Documentation ▼
Manual
Models
Contributing
Wiki
Development ▼
API Docs
Issue Tracker
Merge Requests
API
main-attribute-value.cc
Go to the documentation of this file.
1
/*
2
* Copyright (c) 2008 University of Washington
3
*
4
* This program is free software; you can redistribute it and/or modify
5
* it under the terms of the GNU General Public License version 2 as
6
* published by the Free Software Foundation;
7
*
8
* This program is distributed in the hope that it will be useful,
9
* but WITHOUT ANY WARRANTY; without even the implied warranty of
10
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
* GNU General Public License for more details.
12
*
13
* You should have received a copy of the GNU General Public License
14
* along with this program; if not, write to the Free Software
15
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
*
17
* Author: Tom Henderson <tomh@tomh.org>
18
*/
19
20
#include "ns3/command-line.h"
21
#include "ns3/config.h"
22
#include "ns3/drop-tail-queue.h"
23
#include "ns3/log.h"
24
#include "ns3/node.h"
25
#include "ns3/point-to-point-net-device.h"
26
#include "ns3/pointer.h"
27
#include "ns3/ptr.h"
28
#include "ns3/queue.h"
29
#include "ns3/simulator.h"
30
#include "ns3/string.h"
31
#include "ns3/uinteger.h"
32
33
using namespace
ns3
;
34
35
NS_LOG_COMPONENT_DEFINE
(
"AttributeValueSample"
);
36
37
//
38
// This is a basic example of how to use the attribute system to
39
// set and get a value in the underlying system; namely, the maximum
40
// size of the FIFO queue in the PointToPointNetDevice
41
//
42
43
int
44
main(
int
argc,
char
* argv[])
45
{
46
LogComponentEnable
(
"AttributeValueSample"
,
LOG_LEVEL_INFO
);
47
48
// Queues in ns-3 are objects that hold items (other objects) in
49
// a queue structure. The C++ implementation uses templates to
50
// allow queues to hold various types of items, but the most
51
// common is a pointer to a packet (Ptr<Packet>).
52
//
53
// The maximum queue size can either be enforced in bytes ('b') or
54
// packets ('p'). A special type called the ns3::QueueSize can
55
// hold queue size values in either unit (bytes or packets). The
56
// DropTailQueue<Packet> class has a MaxSize attribute that can
57
// be set to a QueueSize.
58
59
// By default, the MaxSize attribute has a value of 100 packets ('100p')
60
// (this default can be observed in the function DropTail<Item>::GetTypeId)
61
//
62
// Here, we set it to 80 packets. We could use one of two value types:
63
// a string-based value or a QueueSizeValue value
64
Config::SetDefault
(
"ns3::DropTailQueue<Packet>::MaxSize"
,
StringValue
(
"80p"
));
65
// The below function call is redundant
66
Config::SetDefault
(
"ns3::DropTailQueue<Packet>::MaxSize"
,
67
QueueSizeValue
(
QueueSize
(
QueueSizeUnit::PACKETS
, 80)));
68
69
// Allow the user to override any of the defaults and the above
70
// SetDefaults() at run-time, via command-line arguments
71
// For example, via "--ns3::DropTailQueue<Packet>::MaxSize=80p"
72
CommandLine
cmd
(__FILE__);
73
// This provides yet another way to set the value from the command line:
74
cmd
.AddValue(
"maxSize"
,
"ns3::DropTailQueue<Packet>::MaxSize"
);
75
cmd
.Parse(argc, argv);
76
77
// Now, we will create a few objects using the low-level API
78
Ptr<Node>
n0 = CreateObject<Node>();
79
80
Ptr<PointToPointNetDevice>
net0 = CreateObject<PointToPointNetDevice>();
81
n0->
AddDevice
(net0);
82
83
Ptr<Queue<Packet>
> q = CreateObject<DropTailQueue<Packet>>();
84
net0->SetQueue(q);
85
86
// At this point, we have created a single node (Node 0) and a
87
// single PointToPointNetDevice (NetDevice 0) and added a
88
// DropTailQueue to it.
89
90
// Now, we can manipulate the MaxSize value of the already
91
// instantiated DropTailQueue. Here are various ways to do that.
92
93
// We assume that a smart pointer (Ptr) to a relevant network device
94
// is in hand; here, it is the net0 pointer.
95
96
// 1. Pointer-based access
97
//
98
// One way to change the value is to access a pointer to the
99
// underlying queue and modify its attribute.
100
//
101
// First, we observe that we can get a pointer to the (base class)
102
// queue via the PointToPointNetDevice attributes, where it is called
103
// TxQueue
104
PointerValue
ptr;
105
net0->GetAttribute(
"TxQueue"
, ptr);
106
Ptr<Queue<Packet>
> txQueue = ptr.
Get
<
Queue<Packet>
>();
107
108
// Using the GetObject function, we can perform a safe downcast
109
// to a DropTailQueue
110
Ptr<DropTailQueue<Packet>
> dtq = txQueue->GetObject<
DropTailQueue<Packet>
>();
111
NS_ASSERT
(dtq);
112
113
// Next, we can get the value of an attribute on this queue
114
// We have introduced wrapper "Value" classes for the underlying
115
// data types, similar to Java wrappers around these types, since
116
// the attribute system stores values and not disparate types.
117
// Here, the attribute value is assigned to a QueueSizeValue, and
118
// the Get() method on this value produces the (unwrapped) QueueSize.
119
QueueSizeValue
limit;
120
dtq->
GetAttribute
(
"MaxSize"
, limit);
121
NS_LOG_INFO
(
"1. dtq limit: "
<< limit.Get());
122
123
// Note that the above downcast is not really needed; we could have
124
// done the same using the Ptr<Queue> even though the attribute
125
// is a member of the subclass
126
txQueue->GetAttribute(
"MaxSize"
, limit);
127
NS_LOG_INFO
(
"2. txQueue limit: "
<< limit.Get());
128
129
// Now, let's set it to another value (60 packets). Let's also make
130
// use of the StringValue shorthand notation to set the size by
131
// passing in a string (the string must be a positive integer suffixed
132
// by either the 'p' or 'b' character).
133
txQueue->SetAttribute(
"MaxSize"
,
StringValue
(
"60p"
));
134
txQueue->GetAttribute(
"MaxSize"
, limit);
135
NS_LOG_INFO
(
"3. txQueue limit changed: "
<< limit.Get());
136
137
// 2. Namespace-based access
138
//
139
// An alternative way to get at the attribute is to use the configuration
140
// namespace. Here, this attribute resides on a known path in this
141
// namespace; this approach is useful if one doesn't have access to
142
// the underlying pointers and would like to configure a specific
143
// attribute with a single statement.
144
Config::Set
(
"/NodeList/0/DeviceList/0/TxQueue/MaxSize"
,
StringValue
(
"25p"
));
145
txQueue->GetAttribute(
"MaxSize"
, limit);
146
NS_LOG_INFO
(
"4. txQueue limit changed through namespace: "
<< limit.Get());
147
148
// we could have also used wildcards to set this value for all nodes
149
// and all net devices (which in this simple example has the same
150
// effect as the previous Set())
151
Config::Set
(
"/NodeList/*/DeviceList/*/TxQueue/MaxSize"
,
StringValue
(
"15p"
));
152
txQueue->GetAttribute(
"MaxSize"
, limit);
153
NS_LOG_INFO
(
"5. txQueue limit changed through wildcarded namespace: "
<< limit.Get());
154
155
Simulator::Destroy();
156
}
ns3::CommandLine
Parse command-line arguments.
Definition:
command-line.h:232
DropTailQueue< Packet >
ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition:
node.cc:138
ns3::ObjectBase::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition:
object-base.cc:298
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition:
pointer.h:37
ns3::PointerValue::Get
Ptr< T > Get() const
Definition:
pointer.h:205
ns3::Ptr< Node >
Queue< Packet >
ns3::QueueSize
Class for representing queue sizes.
Definition:
queue-size.h:96
QueueSizeValue
AttributeValue implementation for QueueSize.
ns3::StringValue
Hold variables of type string.
Definition:
string.h:42
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition:
assert.h:66
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition:
config.cc:891
ns3::Config::Set
void Set(std::string path, const AttributeValue &value)
Definition:
config.cc:877
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition:
log.h:202
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition:
log.h:275
ns3::PACKETS
@ PACKETS
Use number of packets for queue size.
Definition:
queue-size.h:45
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::LOG_LEVEL_INFO
@ LOG_LEVEL_INFO
LOG_INFO and above.
Definition:
log.h:107
ns3::LogComponentEnable
void LogComponentEnable(const char *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition:
log.cc:358
second.cmd
cmd
Definition:
second.py:33
src
point-to-point
examples
main-attribute-value.cc
Generated on Tue Nov 1 2022 23:00:30 for ns-3 by
1.9.3