A Discrete-Event Network Simulator
API
simple-distributed.cc
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License version 2 as
4  * published by the Free Software Foundation;
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program; if not, write to the Free Software
13  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
14  */
15 
47 #include "mpi-test-fixtures.h"
48 
49 #include "ns3/core-module.h"
50 #include "ns3/internet-stack-helper.h"
51 #include "ns3/ipv4-address-helper.h"
52 #include "ns3/ipv4-global-routing-helper.h"
53 #include "ns3/mpi-interface.h"
54 #include "ns3/network-module.h"
55 #include "ns3/nix-vector-helper.h"
56 #include "ns3/on-off-helper.h"
57 #include "ns3/packet-sink-helper.h"
58 #include "ns3/point-to-point-helper.h"
59 
60 #include <iomanip>
61 #include <mpi.h>
62 
63 using namespace ns3;
64 
65 NS_LOG_COMPONENT_DEFINE("SimpleDistributed");
66 
67 int
68 main(int argc, char* argv[])
69 {
70  bool nix = true;
71  bool nullmsg = false;
72  bool tracing = false;
73  bool testing = false;
74  bool verbose = false;
75 
76  // Parse command line
77  CommandLine cmd(__FILE__);
78  cmd.AddValue("nix", "Enable the use of nix-vector or global routing", nix);
79  cmd.AddValue("nullmsg", "Enable the use of null-message synchronization", nullmsg);
80  cmd.AddValue("tracing", "Enable pcap tracing", tracing);
81  cmd.AddValue("verbose", "verbose output", verbose);
82  cmd.AddValue("test", "Enable regression test output", testing);
83  cmd.Parse(argc, argv);
84 
85  // Distributed simulation setup; by default use granted time window algorithm.
86  if (nullmsg)
87  {
88  GlobalValue::Bind("SimulatorImplementationType",
89  StringValue("ns3::NullMessageSimulatorImpl"));
90  }
91  else
92  {
93  GlobalValue::Bind("SimulatorImplementationType",
94  StringValue("ns3::DistributedSimulatorImpl"));
95  }
96 
97  // Enable parallel simulator with the command line arguments
98  MpiInterface::Enable(&argc, &argv);
99 
101 
102  if (verbose)
103  {
104  LogComponentEnable("PacketSink",
106  }
107 
108  uint32_t systemId = MpiInterface::GetSystemId();
109  uint32_t systemCount = MpiInterface::GetSize();
110 
111  // Check for valid distributed parameters.
112  // Must have 2 and only 2 Logical Processors (LPs)
113  if (systemCount != 2)
114  {
115  std::cout << "This simulation requires 2 and only 2 logical processors." << std::endl;
116  return 1;
117  }
118 
119  // Some default values
120  Config::SetDefault("ns3::OnOffApplication::PacketSize", UintegerValue(512));
121  Config::SetDefault("ns3::OnOffApplication::DataRate", StringValue("1Mbps"));
122  Config::SetDefault("ns3::OnOffApplication::MaxBytes", UintegerValue(512));
123 
124  // Create leaf nodes on left with system id 0
125  NodeContainer leftLeafNodes;
126  leftLeafNodes.Create(4, 0);
127 
128  // Create router nodes. Left router
129  // with system id 0, right router with
130  // system id 1
131  NodeContainer routerNodes;
132  Ptr<Node> routerNode1 = CreateObject<Node>(0);
133  Ptr<Node> routerNode2 = CreateObject<Node>(1);
134  routerNodes.Add(routerNode1);
135  routerNodes.Add(routerNode2);
136 
137  // Create leaf nodes on right with system id 1
138  NodeContainer rightLeafNodes;
139  rightLeafNodes.Create(4, 1);
140 
141  PointToPointHelper routerLink;
142  routerLink.SetDeviceAttribute("DataRate", StringValue("5Mbps"));
143  routerLink.SetChannelAttribute("Delay", StringValue("5ms"));
144 
145  PointToPointHelper leafLink;
146  leafLink.SetDeviceAttribute("DataRate", StringValue("1Mbps"));
147  leafLink.SetChannelAttribute("Delay", StringValue("2ms"));
148 
149  // Add link connecting routers
150  NetDeviceContainer routerDevices;
151  routerDevices = routerLink.Install(routerNodes);
152 
153  // Add links for left side leaf nodes to left router
154  NetDeviceContainer leftRouterDevices;
155  NetDeviceContainer leftLeafDevices;
156  for (uint32_t i = 0; i < 4; ++i)
157  {
158  NetDeviceContainer temp = leafLink.Install(leftLeafNodes.Get(i), routerNodes.Get(0));
159  leftLeafDevices.Add(temp.Get(0));
160  leftRouterDevices.Add(temp.Get(1));
161  }
162 
163  // Add links for right side leaf nodes to right router
164  NetDeviceContainer rightRouterDevices;
165  NetDeviceContainer rightLeafDevices;
166  for (uint32_t i = 0; i < 4; ++i)
167  {
168  NetDeviceContainer temp = leafLink.Install(rightLeafNodes.Get(i), routerNodes.Get(1));
169  rightLeafDevices.Add(temp.Get(0));
170  rightRouterDevices.Add(temp.Get(1));
171  }
172 
174  if (nix)
175  {
177  stack.SetRoutingHelper(nixRouting); // has effect on the next Install ()
178  }
179 
180  stack.InstallAll();
181 
182  Ipv4InterfaceContainer routerInterfaces;
183  Ipv4InterfaceContainer leftLeafInterfaces;
184  Ipv4InterfaceContainer leftRouterInterfaces;
185  Ipv4InterfaceContainer rightLeafInterfaces;
186  Ipv4InterfaceContainer rightRouterInterfaces;
187 
188  Ipv4AddressHelper leftAddress;
189  leftAddress.SetBase("10.1.1.0", "255.255.255.0");
190 
191  Ipv4AddressHelper routerAddress;
192  routerAddress.SetBase("10.2.1.0", "255.255.255.0");
193 
194  Ipv4AddressHelper rightAddress;
195  rightAddress.SetBase("10.3.1.0", "255.255.255.0");
196 
197  // Router-to-Router interfaces
198  routerInterfaces = routerAddress.Assign(routerDevices);
199 
200  // Left interfaces
201  for (uint32_t i = 0; i < 4; ++i)
202  {
203  NetDeviceContainer ndc;
204  ndc.Add(leftLeafDevices.Get(i));
205  ndc.Add(leftRouterDevices.Get(i));
206  Ipv4InterfaceContainer ifc = leftAddress.Assign(ndc);
207  leftLeafInterfaces.Add(ifc.Get(0));
208  leftRouterInterfaces.Add(ifc.Get(1));
209  leftAddress.NewNetwork();
210  }
211 
212  // Right interfaces
213  for (uint32_t i = 0; i < 4; ++i)
214  {
215  NetDeviceContainer ndc;
216  ndc.Add(rightLeafDevices.Get(i));
217  ndc.Add(rightRouterDevices.Get(i));
218  Ipv4InterfaceContainer ifc = rightAddress.Assign(ndc);
219  rightLeafInterfaces.Add(ifc.Get(0));
220  rightRouterInterfaces.Add(ifc.Get(1));
221  rightAddress.NewNetwork();
222  }
223 
224  if (!nix)
225  {
227  }
228 
229  if (tracing)
230  {
231  if (systemId == 0)
232  {
233  routerLink.EnablePcap("router-left", routerDevices, true);
234  leafLink.EnablePcap("leaf-left", leftLeafDevices, true);
235  }
236 
237  if (systemId == 1)
238  {
239  routerLink.EnablePcap("router-right", routerDevices, true);
240  leafLink.EnablePcap("leaf-right", rightLeafDevices, true);
241  }
242  }
243 
244  // Create a packet sink on the right leafs to receive packets from left leafs
245 
246  uint16_t port = 50000;
247  if (systemId == 1)
248  {
249  Address sinkLocalAddress(InetSocketAddress(Ipv4Address::GetAny(), port));
250  PacketSinkHelper sinkHelper("ns3::UdpSocketFactory", sinkLocalAddress);
251  ApplicationContainer sinkApp;
252  for (uint32_t i = 0; i < 4; ++i)
253  {
254  sinkApp.Add(sinkHelper.Install(rightLeafNodes.Get(i)));
255  if (testing)
256  {
257  sinkApp.Get(i)->TraceConnectWithoutContext("RxWithAddresses",
259  }
260  }
261  sinkApp.Start(Seconds(1.0));
262  sinkApp.Stop(Seconds(5));
263  }
264 
265  // Create the OnOff applications to send
266  if (systemId == 0)
267  {
268  OnOffHelper clientHelper("ns3::UdpSocketFactory", Address());
269  clientHelper.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
270  clientHelper.SetAttribute("OffTime",
271  StringValue("ns3::ConstantRandomVariable[Constant=0]"));
272 
274  for (uint32_t i = 0; i < 4; ++i)
275  {
276  AddressValue remoteAddress(InetSocketAddress(rightLeafInterfaces.GetAddress(i), port));
277  clientHelper.SetAttribute("Remote", remoteAddress);
278  clientApps.Add(clientHelper.Install(leftLeafNodes.Get(i)));
279  }
280  clientApps.Start(Seconds(1.0));
281  clientApps.Stop(Seconds(5));
282  }
283 
285  Simulator::Run();
287 
288  if (testing)
289  {
291  }
292 
293  // Exit the MPI execution environment
295  return 0;
296 }
a polymophic address class
Definition: address.h:101
holds a vector of ns3::Application pointers.
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container.
Parse command-line arguments.
Definition: command-line.h:232
static void Bind(std::string name, const AttributeValue &value)
Iterate over the set of GlobalValues until a matching name is found and then set its value with Globa...
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...
static Ipv4Address GetAny()
static void PopulateRoutingTables()
Build a routing database and initialize the routing tables of the nodes in the simulation.
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
static uint32_t GetSystemId()
Get the id number of this rank.
static uint32_t GetSize()
Get the number of ranks used by ns-3.
static void Disable()
Clean up the ns-3 parallel communications interface.
static void Enable(int *pargc, char ***pargv)
Setup the parallel communication interface.
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:315
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)
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
static void Run()
Run the simulation.
Definition: simulator.cc:178
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186
static void SinkTrace(const ns3::Ptr< const ns3::Packet > packet, const ns3::Address &srcAddress, const ns3::Address &destAddress)
PacketSink receive trace callback.
static void Verify(unsigned long expectedCount)
Verify the sink trace count observed matches the expected count.
static void Init()
PacketSink Init.
Hold variables of type string.
Definition: string.h:56
Hold an unsigned integer type.
Definition: uinteger.h:45
uint16_t port
Definition: dsdv-manet.cc:44
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:890
#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:1326
Common methods for MPI examples.
clientApps
Definition: first.py:64
stack
Definition: first.py:44
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:302
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:704
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:104
cmd
Definition: second.py:40
bool verbose
bool tracing
Flag to enable/disable generation of tracing files.