-
Notifications
You must be signed in to change notification settings - Fork 0
/
manet-routing-compare.cc
428 lines (366 loc) · 13.8 KB
/
manet-routing-compare.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
/*
* Copyright (c) 2011 University of Kansas
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Justin Rohrer <rohrej@ittc.ku.edu>
*
* James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
* ResiliNets Research Group https://resilinets.org/
* Information and Telecommunication Technology Center (ITTC)
* and Department of Electrical Engineering and Computer Science
* The University of Kansas Lawrence, KS USA.
*
* Work supported in part by NSF FIND (Future Internet Design) Program
* under grant CNS-0626918 (Postmodern Internet Architecture),
* NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
* US Department of Defense (DoD), and ITTC at The University of Kansas.
*/
/*
* This example program allows one to run ns-3 DSDV, AODV, or OLSR under
* a typical random waypoint mobility model.
*
* By default, the simulation runs for 200 simulated seconds, of which
* the first 50 are used for start-up time. The number of nodes is 50.
* Nodes move according to RandomWaypointMobilityModel with a speed of
* 20 m/s and no pause time within a 300x1500 m region. The WiFi is
* in ad hoc mode with a 2 Mb/s rate (802.11b) and a Friis loss model.
* The transmit power is set to 7.5 dBm.
*
* It is possible to change the mobility and density of the network by
* directly modifying the speed and the number of nodes. It is also
* possible to change the characteristics of the network by changing
* the transmit power (as power increases, the impact of mobility
* decreases and the effective density increases).
*
* By default, OLSR is used, but specifying a value of 2 for the protocol
* will cause AODV to be used, and specifying a value of 3 will cause
* DSDV to be used.
*
* By default, there are 10 source/sink data pairs sending UDP data
* at an application rate of 2.048 Kb/s each. This is typically done
* at a rate of 4 64-byte packets per second. Application data is
* started at a random time between 50 and 51 seconds and continues
* to the end of the simulation.
*
* The program outputs a few items:
* - packet receptions are notified to stdout such as:
* <timestamp> <node-id> received one packet from <src-address>
* - each second, the data reception statistics are tabulated and output
* to a comma-separated value (csv) file
* - some tracing and flow monitor configuration that used to work is
* left commented inline in the program
*/
#include "ns3/aodv-module.h"
#include "ns3/applications-module.h"
#include "ns3/core-module.h"
#include "ns3/dsdv-module.h"
#include "ns3/dsr-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/network-module.h"
#include "ns3/olsr-module.h"
#include "ns3/yans-wifi-helper.h"
#include <fstream>
#include <iostream>
using namespace ns3;
using namespace dsr;
NS_LOG_COMPONENT_DEFINE("manet-routing-compare");
/**
* Routing experiment class.
*
* It handles the creation and run of an experiment.
*/
class RoutingExperiment
{
public:
RoutingExperiment();
/**
* Run the experiment.
* \param nSinks The number of Sink Nodes.
* \param txp The Tx power.
* \param CSVfileName The output CSV filename.
*/
void Run(int nSinks, double txp, std::string CSVfileName);
// static void SetMACParam (ns3::NetDeviceContainer & devices,
// int slotDistance);
/**
* Handles the command-line parmeters.
* \param argc The argument count.
* \param argv The argument vector.
* \return the CSV filename.
*/
std::string CommandSetup(int argc, char** argv);
private:
/**
* Setup the receiving socket in a Sink Node.
* \param addr The address of the node.
* \param node The node pointer.
* \return the socket.
*/
Ptr<Socket> SetupPacketReceive(Ipv4Address addr, Ptr<Node> node);
/**
* Receive a packet.
* \param socket The receiving socket.
*/
void ReceivePacket(Ptr<Socket> socket);
/**
* Compute the throughput.
*/
void CheckThroughput();
uint32_t port; //!< Receiving port number.
uint32_t bytesTotal; //!< Total received bytes.
uint32_t packetsReceived; //!< Total received packets.
std::string m_CSVfileName; //!< CSV filename.
int m_nSinks; //!< Number of sink nodes.
std::string m_protocolName; //!< Protocol name.
double m_txp; //!< Tx power.
bool m_traceMobility; //!< Enavle mobility tracing.
uint32_t m_protocol; //!< Protocol type.
};
RoutingExperiment::RoutingExperiment()
: port(9),
bytesTotal(0),
packetsReceived(0),
m_CSVfileName("aodv.output.csv"),
m_traceMobility(false),
m_protocol(2) // AODV
{
}
static inline std::string
PrintReceivedPacket(Ptr<Socket> socket, Ptr<Packet> packet, Address senderAddress)
{
std::ostringstream oss;
oss << Simulator::Now().GetSeconds() << " " << socket->GetNode()->GetId();
if (InetSocketAddress::IsMatchingType(senderAddress))
{
InetSocketAddress addr = InetSocketAddress::ConvertFrom(senderAddress);
oss << " received one packet from " << addr.GetIpv4();
}
else
{
oss << " received one packet!";
}
return oss.str();
}
void
RoutingExperiment::ReceivePacket(Ptr<Socket> socket)
{
Ptr<Packet> packet;
Address senderAddress;
while ((packet = socket->RecvFrom(senderAddress)))
{
bytesTotal += packet->GetSize();
packetsReceived += 1;
NS_LOG_UNCOND(PrintReceivedPacket(socket, packet, senderAddress));
}
}
void
RoutingExperiment::CheckThroughput()
{
double kbs = (bytesTotal * 8.0) / 1000;
bytesTotal = 0;
std::ofstream out(m_CSVfileName, std::ios::app);
out << (Simulator::Now()).GetSeconds() << "," << kbs << "," << packetsReceived << ","
<< m_nSinks << "," << m_protocolName << "," << m_txp << "" << std::endl;
out.close();
packetsReceived = 0;
Simulator::Schedule(Seconds(1.0), &RoutingExperiment::CheckThroughput, this);
}
Ptr<Socket>
RoutingExperiment::SetupPacketReceive(Ipv4Address addr, Ptr<Node> node)
{
TypeId tid = TypeId::LookupByName("ns3::UdpSocketFactory");
Ptr<Socket> sink = Socket::CreateSocket(node, tid);
InetSocketAddress local = InetSocketAddress(addr, port);
sink->Bind(local);
sink->SetRecvCallback(MakeCallback(&RoutingExperiment::ReceivePacket, this));
return sink;
}
std::string
RoutingExperiment::CommandSetup(int argc, char** argv)
{
CommandLine cmd(__FILE__);
cmd.AddValue("CSVfileName", "The name of the CSV output file name", m_CSVfileName);
cmd.AddValue("traceMobility", "Enable mobility tracing", m_traceMobility);
cmd.AddValue("protocol", "1=OLSR;2=AODV;3=DSDV;4=DSR", m_protocol);
cmd.Parse(argc, argv);
return m_CSVfileName;
}
int
main(int argc, char* argv[])
{
RoutingExperiment experiment;
std::string CSVfileName = experiment.CommandSetup(argc, argv);
// blank out the last output file and write the column headers
std::ofstream out(CSVfileName);
out << "SimulationSecond,"
<< "ReceiveRate,"
<< "PacketsReceived,"
<< "NumberOfSinks,"
<< "RoutingProtocol,"
<< "TransmissionPower" << std::endl;
out.close();
int nSinks = 10;
double txp = 7.5;
experiment.Run(nSinks, txp, CSVfileName);
return 0;
}
void
RoutingExperiment::Run(int nSinks, double txp, std::string CSVfileName)
{
Packet::EnablePrinting();
m_nSinks = nSinks;
m_txp = txp;
m_CSVfileName = CSVfileName;
int nWifis = 50;
double TotalTime = 200.0;
std::string rate("2048bps");
std::string phyMode("DsssRate11Mbps");
std::string tr_name("manet-routing-compare");
int nodeSpeed = 20; // in m/s
int nodePause = 0; // in s
m_protocolName = "protocol";
Config::SetDefault("ns3::OnOffApplication::PacketSize", StringValue("64"));
Config::SetDefault("ns3::OnOffApplication::DataRate", StringValue(rate));
// Set Non-unicastMode rate to unicast mode
Config::SetDefault("ns3::WifiRemoteStationManager::NonUnicastMode", StringValue(phyMode));
NodeContainer adhocNodes;
adhocNodes.Create(nWifis);
// setting up wifi phy and channel using helpers
WifiHelper wifi;
wifi.SetStandard(WIFI_STANDARD_80211b);
YansWifiPhyHelper wifiPhy;
YansWifiChannelHelper wifiChannel;
wifiChannel.SetPropagationDelay("ns3::ConstantSpeedPropagationDelayModel");
wifiChannel.AddPropagationLoss("ns3::FriisPropagationLossModel");
wifiPhy.SetChannel(wifiChannel.Create());
// Add a mac and disable rate control
WifiMacHelper wifiMac;
wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
"DataMode",
StringValue(phyMode),
"ControlMode",
StringValue(phyMode));
wifiPhy.Set("TxPowerStart", DoubleValue(txp));
wifiPhy.Set("TxPowerEnd", DoubleValue(txp));
wifiMac.SetType("ns3::AdhocWifiMac");
NetDeviceContainer adhocDevices = wifi.Install(wifiPhy, wifiMac, adhocNodes);
MobilityHelper mobilityAdhoc;
int64_t streamIndex = 0; // used to get consistent mobility across scenarios
ObjectFactory pos;
pos.SetTypeId("ns3::RandomRectanglePositionAllocator");
pos.Set("X", StringValue("ns3::UniformRandomVariable[Min=0.0|Max=300.0]"));
pos.Set("Y", StringValue("ns3::UniformRandomVariable[Min=0.0|Max=1500.0]"));
Ptr<PositionAllocator> taPositionAlloc = pos.Create()->GetObject<PositionAllocator>();
streamIndex += taPositionAlloc->AssignStreams(streamIndex);
std::stringstream ssSpeed;
ssSpeed << "ns3::UniformRandomVariable[Min=0.0|Max=" << nodeSpeed << "]";
std::stringstream ssPause;
ssPause << "ns3::ConstantRandomVariable[Constant=" << nodePause << "]";
mobilityAdhoc.SetMobilityModel("ns3::RandomWaypointMobilityModel",
"Speed",
StringValue(ssSpeed.str()),
"Pause",
StringValue(ssPause.str()),
"PositionAllocator",
PointerValue(taPositionAlloc));
mobilityAdhoc.SetPositionAllocator(taPositionAlloc);
mobilityAdhoc.Install(adhocNodes);
streamIndex += mobilityAdhoc.AssignStreams(adhocNodes, streamIndex);
AodvHelper aodv;
OlsrHelper olsr;
DsdvHelper dsdv;
DsrHelper dsr;
DsrMainHelper dsrMain;
Ipv4ListRoutingHelper list;
InternetStackHelper internet;
switch (m_protocol)
{
case 1:
list.Add(olsr, 100);
m_protocolName = "OLSR";
break;
case 2:
list.Add(aodv, 100);
m_protocolName = "AODV";
break;
case 3:
list.Add(dsdv, 100);
m_protocolName = "DSDV";
break;
case 4:
m_protocolName = "DSR";
break;
default:
NS_FATAL_ERROR("No such protocol:" << m_protocol);
}
if (m_protocol < 4)
{
internet.SetRoutingHelper(list);
internet.Install(adhocNodes);
}
else if (m_protocol == 4)
{
internet.Install(adhocNodes);
dsrMain.Install(dsr, adhocNodes);
}
NS_LOG_INFO("assigning ip address");
Ipv4AddressHelper addressAdhoc;
addressAdhoc.SetBase("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer adhocInterfaces;
adhocInterfaces = addressAdhoc.Assign(adhocDevices);
OnOffHelper onoff1("ns3::UdpSocketFactory", Address());
onoff1.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1.0]"));
onoff1.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0.0]"));
for (int i = 0; i < nSinks; i++)
{
Ptr<Socket> sink = SetupPacketReceive(adhocInterfaces.GetAddress(i), adhocNodes.Get(i));
AddressValue remoteAddress(InetSocketAddress(adhocInterfaces.GetAddress(i), port));
onoff1.SetAttribute("Remote", remoteAddress);
Ptr<UniformRandomVariable> var = CreateObject<UniformRandomVariable>();
ApplicationContainer temp = onoff1.Install(adhocNodes.Get(i + nSinks));
temp.Start(Seconds(var->GetValue(100.0, 101.0)));
temp.Stop(Seconds(TotalTime));
}
std::stringstream ss;
ss << nWifis;
std::string nodes = ss.str();
std::stringstream ss2;
ss2 << nodeSpeed;
std::string sNodeSpeed = ss2.str();
std::stringstream ss3;
ss3 << nodePause;
std::string sNodePause = ss3.str();
std::stringstream ss4;
ss4 << rate;
std::string sRate = ss4.str();
// NS_LOG_INFO("Configure Tracing.");
// tr_name = tr_name + "_" + m_protocolName +"_" + nodes + "nodes_" + sNodeSpeed + "speed_" +
// sNodePause + "pause_" + sRate + "rate";
// AsciiTraceHelper ascii;
// Ptr<OutputStreamWrapper> osw = ascii.CreateFileStream(tr_name + ".tr");
// wifiPhy.EnableAsciiAll(osw);
AsciiTraceHelper ascii;
MobilityHelper::EnableAsciiAll(ascii.CreateFileStream(tr_name + ".mob"));
// Ptr<FlowMonitor> flowmon;
// FlowMonitorHelper flowmonHelper;
// flowmon = flowmonHelper.InstallAll();
NS_LOG_INFO("Run Simulation.");
CheckThroughput();
Simulator::Stop(Seconds(TotalTime));
Simulator::Run();
// flowmon->SerializeToXmlFile(tr_name + ".flowmon", false, false);
Simulator::Destroy();
}