A Discrete-Event Network Simulator
API
simple-distributed-empty-node.cc
Go to the documentation of this file.
1/*
2 * Copyright 2013. Lawrence Livermore National Security, LLC.
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: Steven Smith <smith84@llnl.gov>
18 */
19
66#include "mpi-test-fixtures.h"
67#include "mpi.h"
68
69#include "ns3/core-module.h"
70#include "ns3/internet-stack-helper.h"
71#include "ns3/ipv4-address-helper.h"
72#include "ns3/ipv4-global-routing-helper.h"
73#include "ns3/mpi-interface.h"
74#include "ns3/network-module.h"
75#include "ns3/nix-vector-helper.h"
76#include "ns3/on-off-helper.h"
77#include "ns3/packet-sink-helper.h"
78#include "ns3/point-to-point-helper.h"
79
80using namespace ns3;
81
82NS_LOG_COMPONENT_DEFINE("SimpleDistributedEmptyNode");
83
84int
85main(int argc, char* argv[])
86{
87 bool nix = true;
88 bool nullmsg = false;
89 bool tracing = false;
90 bool testing = false;
91 bool verbose = false;
92
93 // Parse command line
94 CommandLine cmd(__FILE__);
95 cmd.AddValue("nix", "Enable the use of nix-vector or global routing", nix);
96 cmd.AddValue("nullmsg", "Enable the use of null-message synchronization", nullmsg);
97 cmd.AddValue("tracing", "Enable pcap tracing", tracing);
98 cmd.AddValue("verbose", "verbose output", verbose);
99 cmd.AddValue("test", "Enable regression test output", testing);
100 cmd.Parse(argc, argv);
101
102 // Distributed simulation setup; by default use granted time window algorithm.
103 if (nullmsg)
104 {
105 GlobalValue::Bind("SimulatorImplementationType",
106 StringValue("ns3::NullMessageSimulatorImpl"));
107 }
108 else
109 {
110 GlobalValue::Bind("SimulatorImplementationType",
111 StringValue("ns3::DistributedSimulatorImpl"));
112 }
113
114 MpiInterface::Enable(&argc, &argv);
115
116 SinkTracer::Init();
117
118 if (verbose)
119 {
120 LogComponentEnable("PacketSink",
122 }
123
124 uint32_t systemId = MpiInterface::GetSystemId();
125 uint32_t systemCount = MpiInterface::GetSize();
126
127 uint32_t rightHalfSystemId = 777;
128
129 // Check for valid distributed parameters.
130 // Must have 2 or 3 tasks.
131 if (systemCount == 2)
132 {
133 rightHalfSystemId = 0;
134 }
135 else if (systemCount == 3)
136 {
137 rightHalfSystemId = 1;
138 }
139 else
140 {
141 std::cout << "This simulation requires 2 or 3 logical processors." << std::endl;
142 return 1;
143 }
144
145 // Some default values
146 Config::SetDefault("ns3::OnOffApplication::PacketSize", UintegerValue(512));
147 Config::SetDefault("ns3::OnOffApplication::DataRate", StringValue("1Mbps"));
148 Config::SetDefault("ns3::OnOffApplication::MaxBytes", UintegerValue(512));
149
150 // Create leaf nodes on left with system id 0
151 NodeContainer leftLeafNodes;
152 leftLeafNodes.Create(4, 0);
153
154 // Create router nodes. Left router with system id 0, right router
155 // with system id dependent on number of processors using
156 // rightHalfSystemId
157 NodeContainer routerNodes;
158 Ptr<Node> routerNode1 = CreateObject<Node>(0);
159 Ptr<Node> routerNode2 = CreateObject<Node>(rightHalfSystemId);
160 routerNodes.Add(routerNode1);
161 routerNodes.Add(routerNode2);
162
163 // Create leaf nodes on left with system id rightHalfSystemId
164 NodeContainer rightLeafNodes;
165 rightLeafNodes.Create(4, rightHalfSystemId);
166
167 PointToPointHelper routerLink;
168 routerLink.SetDeviceAttribute("DataRate", StringValue("5Mbps"));
169 routerLink.SetChannelAttribute("Delay", StringValue("5ms"));
170
171 PointToPointHelper leafLink;
172 leafLink.SetDeviceAttribute("DataRate", StringValue("1Mbps"));
173 leafLink.SetChannelAttribute("Delay", StringValue("2ms"));
174
175 // Add link connecting routers
176 NetDeviceContainer routerDevices;
177 routerDevices = routerLink.Install(routerNodes);
178
179 // Add links for left side leaf nodes to left router
180 NetDeviceContainer leftRouterDevices;
181 NetDeviceContainer leftLeafDevices;
182 for (uint32_t i = 0; i < 4; ++i)
183 {
184 NetDeviceContainer temp = leafLink.Install(leftLeafNodes.Get(i), routerNodes.Get(0));
185 leftLeafDevices.Add(temp.Get(0));
186 leftRouterDevices.Add(temp.Get(1));
187 }
188
189 // Add links for right side leaf nodes to right router
190 NetDeviceContainer rightRouterDevices;
191 NetDeviceContainer rightLeafDevices;
192 for (uint32_t i = 0; i < 4; ++i)
193 {
194 NetDeviceContainer temp = leafLink.Install(rightLeafNodes.Get(i), routerNodes.Get(1));
195 rightLeafDevices.Add(temp.Get(0));
196 rightRouterDevices.Add(temp.Get(1));
197 }
198
200 if (nix)
201 {
202 Ipv4NixVectorHelper nixRouting;
203 stack.SetRoutingHelper(nixRouting); // has effect on the next Install ()
204 }
205
206 stack.InstallAll();
207
208 Ipv4InterfaceContainer routerInterfaces;
209 Ipv4InterfaceContainer leftLeafInterfaces;
210 Ipv4InterfaceContainer leftRouterInterfaces;
211 Ipv4InterfaceContainer rightLeafInterfaces;
212 Ipv4InterfaceContainer rightRouterInterfaces;
213
214 Ipv4AddressHelper leftAddress;
215 leftAddress.SetBase("10.1.1.0", "255.255.255.0");
216
217 Ipv4AddressHelper routerAddress;
218 routerAddress.SetBase("10.2.1.0", "255.255.255.0");
219
220 Ipv4AddressHelper rightAddress;
221 rightAddress.SetBase("10.3.1.0", "255.255.255.0");
222
223 // Router-to-Router interfaces
224 routerInterfaces = routerAddress.Assign(routerDevices);
225
226 // Left interfaces
227 for (uint32_t i = 0; i < 4; ++i)
228 {
230 ndc.Add(leftLeafDevices.Get(i));
231 ndc.Add(leftRouterDevices.Get(i));
232 Ipv4InterfaceContainer ifc = leftAddress.Assign(ndc);
233 leftLeafInterfaces.Add(ifc.Get(0));
234 leftRouterInterfaces.Add(ifc.Get(1));
235 leftAddress.NewNetwork();
236 }
237
238 // Right interfaces
239 for (uint32_t i = 0; i < 4; ++i)
240 {
242 ndc.Add(rightLeafDevices.Get(i));
243 ndc.Add(rightRouterDevices.Get(i));
244 Ipv4InterfaceContainer ifc = rightAddress.Assign(ndc);
245 rightLeafInterfaces.Add(ifc.Get(0));
246 rightRouterInterfaces.Add(ifc.Get(1));
247 rightAddress.NewNetwork();
248 }
249
250 if (!nix)
251 {
252 Ipv4GlobalRoutingHelper::PopulateRoutingTables();
253 }
254
255 if (tracing == true)
256 {
257 if (systemId == 0)
258 {
259 routerLink.EnablePcap("router-left", routerDevices, true);
260 leafLink.EnablePcap("leaf-left", leftLeafDevices, true);
261 }
262
263 if (systemId == rightHalfSystemId)
264 {
265 routerLink.EnablePcap("router-right", routerDevices, true);
266 leafLink.EnablePcap("leaf-right", rightLeafDevices, true);
267 }
268 }
269
270 // Create a packet sink on the right leafs to receive packets from left leafs
271 uint16_t port = 50000;
272 if (systemId == rightHalfSystemId)
273 {
274 Address sinkLocalAddress(InetSocketAddress(Ipv4Address::GetAny(), port));
275 PacketSinkHelper sinkHelper("ns3::UdpSocketFactory", sinkLocalAddress);
276 ApplicationContainer sinkApp;
277 for (uint32_t i = 0; i < 4; ++i)
278 {
279 sinkApp.Add(sinkHelper.Install(rightLeafNodes.Get(i)));
280 if (testing)
281 {
282 sinkApp.Get(i)->TraceConnectWithoutContext("RxWithAddresses",
283 MakeCallback(&SinkTracer::SinkTrace));
284 }
285 }
286 sinkApp.Start(Seconds(1.0));
287 sinkApp.Stop(Seconds(5));
288 }
289
290 // Create the OnOff applications to send
291 if (systemId == 0)
292 {
293 OnOffHelper clientHelper("ns3::UdpSocketFactory", Address());
294 clientHelper.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
295 clientHelper.SetAttribute("OffTime",
296 StringValue("ns3::ConstantRandomVariable[Constant=0]"));
297
299 for (uint32_t i = 0; i < 4; ++i)
300 {
301 AddressValue remoteAddress(InetSocketAddress(rightLeafInterfaces.GetAddress(i), port));
302 clientHelper.SetAttribute("Remote", remoteAddress);
303 clientApps.Add(clientHelper.Install(leftLeafNodes.Get(i)));
304 }
305 clientApps.Start(Seconds(1.0));
306 clientApps.Stop(Seconds(5));
307 }
308
309 Simulator::Stop(Seconds(5));
310 Simulator::Run();
311 Simulator::Destroy();
312
313 if (testing)
314 {
315 SinkTracer::Verify(4);
316 }
317
318 // Exit the MPI execution environment
319 MpiInterface::Disable();
320 return 0;
321}
a polymophic address class
Definition: address.h:92
AttributeValue implementation for Address.
holds a vector of ns3::Application pointers.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Parse command-line arguments.
Definition: command-line.h:232
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4Address NewNetwork()
Increment the network number and reset the IP address counter to the base value provided in the SetBa...
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
holds a vector of std::pair of Ptr<Ipv4> and interface index.
std::pair< Ptr< Ipv4 >, uint32_t > Get(uint32_t i) const
Get the std::pair of an Ptr<Ipv4> and interface stored at the location specified by the index.
void Add(const Ipv4InterfaceContainer &other)
Concatenate the entries in the other container with ours.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
holds a vector of ns3::NetDevice pointers
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Helper class that adds Nix-vector routing to nodes.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void Add(const NodeContainer &nc)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:369
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:44
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
void EnablePcap(std::string prefix, Ptr< NetDevice > nd, bool promiscuous=false, bool explicitFilename=false)
Enable pcap output the indicated net device.
Build a set of PointToPointNetDevice objects.
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
NetDeviceContainer Install(NodeContainer c)
Hold variables of type string.
Definition: string.h:42
Hold an unsigned integer type.
Definition: uinteger.h:45
uint16_t port
Definition: dsdv-manet.cc:45
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
Common methods for MPI examples.
clientApps
Definition: first.py:58
stack
Definition: first.py:37
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:691
LogLevel
Logging severity classes and levels.
Definition: log.h:94
@ LOG_PREFIX_TIME
Prefix all trace prints with simulation time.
Definition: log.h:119
@ LOG_PREFIX_NODE
Prefix all trace prints with simulation node.
Definition: log.h:120
@ LOG_LEVEL_INFO
LOG_INFO and above.
Definition: log.h:107
uint32_t GetSize(Ptr< const Packet > packet, const WifiMacHeader *hdr, bool isAmpdu)
Return the total size of the packet after WifiMacHeader and FCS trailer have been added.
Definition: wifi-utils.cc:132
void LogComponentEnable(const char *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:358
cmd
Definition: second.py:33
bool verbose
bool tracing
Flag to enable/disable generation of tracing files.