Darshan Singh

119CS0169
Network Simulation Lab Assignment – 7

AODV:

The AODV protocol builds routes between nodes only if they are requested by source nodes.
AODV is therefore considered an on-demand algorithm and does not create any extra traffic for
communication along links. The routes are maintained as long as they are required by the sources.
They also form trees to connect multicast group members. AODV makes use of sequence numbers
to ensure route freshness. They are self-starting and loop-free besides scaling to numerous mobile
nodes.

Types of routing in AODV :

It consists of 3 types of routing messages as follows.

RREQ: Route Request –

A node, Initiates to send/transmit a packet but doesn’t know how to get there, it sends an RREQ
multicast message to start the route discovery process. Neighboring nodes keep track of where
the message originated and move it on to their neighbors before it reaches the destination node.

RREP: Route Reply –

The destination node responds with an RREP, which returns to the source through the path taken
by the RREQ. As the RREP returns to the source, forward routes are formed in the intermediate
nodes. If an intermediate node knows the path to the destination, it may send an RREP in
response to a received RREQ, allowing nodes to enter an established route. Communication
between the source and the destination will begin once the RREP arrives at the source and the
route is established.

REER: Route Error –

AODV typically has less overhead as a reactive protocol (less route maintenance messages) than
proactive. In the event of the connection interruption that the path no longer functions, i.e.
messages cannot be sent, a RERR message is sent through a node detecting the link interruption.
The message is re-cast by other nodes. The RERR message shows the unattainable destination.
Message receiving nodes inactivates the route.

Q1:

Code:

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*
* Copyright (c) 2009 IITP RAS
*
* 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 *
* This is an example script for AODV manet routing protocol. *
* Authors: Pavel Boyko <boyko@iitp.ru>
*/

#include <iostream>
#include <cmath>
#include "ns3/aodv-module.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/v4ping-helper.h"
#include "ns3/yans-wifi-helper.h"
#include "ns3/netanim-module.h"
using namespace ns3;

/**
* \ingroup aodv-examples
* \ingroup examples * \brief Test script. *
* This script creates 1-dimensional grid topology and then ping last node from the first one:
*
* [10.0.0.1] <-- step --> [10.0.0.2] <-- step --> [10.0.0.3] <-- step --> [10.0.0.4] *
* ping 10.0.0.4
*
* When 1/3 of simulation time has elapsed, one of the nodes is moved out of
* range, thereby breaking the topology. By default, this will result in * only 34 of 100 pings being
received. If the step size is reduced * to cover the gap, then all pings can be received.
*/
class AodvExample
{
public:
 AodvExample ();
/**
* \brief Configure script parameters
* \param argc is the command line argument count
* \param argv is the command line arguments
* \return true on successful configuration
*/
bool Configure (int argc, char **argv);
/// Run simulation
void Run ();
/**
* Report results
* \param os the output stream
*/
void Report (std::ostream & os);

private:

// parameters ///
Number of nodes
uint32_t size;
/// Distance between nodes, meters
double step;
/// Simulation time, seconds
double totalTime;
/// Write per-device PCAP traces if true
bool pcap;
/// Print routes if true
bool printRoutes;

// network
/// nodes used in the example
NodeContainer nodes;
/// devices used in the example
NetDeviceContainer devices;
/// interfaces used in the example
Ipv4InterfaceContainer interfaces;

private: /// Create the nodes void

CreateNodes (); /// Create the
devices void CreateDevices (); ///
Create the network void
InstallInternetStack (); /// Create
the simulation applications void
InstallApplications ();
};

int main (int argc, char **argv)

{
AodvExample test; if
(!test.Configure (argc, argv))
NS_FATAL_ERROR ("Configuration failed. Aborted.");

test.Run ();
test.Report (std::cout);

return 0;
}

//----------------------------------------------------------------------------AodvExample::AodvExample () :
size (10), step
(50), totalTime
(10), pcap
(true),
printRoutes (true)
{}

bool
AodvExample::Configure (int argc, char **argv)
{
// Enable AODV logs by default. Comment this if too noisy
//LogComponentEnable("AodvRoutingProtocol", LOG_LEVEL_ALL);

SeedManager::SetSeed (12345);
CommandLine cmd;

cmd.AddValue ("pcap", "Write PCAP traces.", pcap);

cmd.AddValue ("printRoutes", "Print routing table dumps.",
printRoutes); cmd.AddValue ("size", "Number of nodes.", size);
cmd.AddValue ("time", "Simulation time, s.", totalTime); cmd.AddValue
("step", "Grid step, m", step);

cmd.Parse (argc, argv);

return true;
}

void
AodvExample::Run ()
{
// Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", UintegerValue (1)); //
enable rts cts all the time.
CreateNodes ();
CreateDevices ();
InstallInternetStack (); InstallApplications (); std::cout <<
"Starting simulation for " << totalTime << " s ...\n";

Simulator::Stop (Seconds (totalTime));

AnimationInterface anim("seven.xml");
Simulator::Run ();

Simulator::Destroy ();
}

void
AodvExample::Report (std::ostream &)
{
}
void
AodvExample::CreateNodes ()
{
std::cout << "Creating " << (unsigned)size << " nodes " << step << " m apart.\n";
nodes.Create (size); // Name nodes
for (uint32_t i = 0; i < size; ++i)
{
std::ostringstream os;
os << "node-" << i;
Names::Add (os.str (), nodes.Get (i));
}
// Create static grid
MobilityHelper mobility;
mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (step),
"DeltaY", DoubleValue (0),
"GridWidth", UintegerValue (size),
"LayoutType", StringValue ("RowFirst"));
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install
(nodes);
}

void
AodvExample::CreateDevices ()
{
WifiMacHelper wifiMac;
wifiMac.SetType ("ns3::AdhocWifiMac");
YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
wifiPhy.SetChannel (wifiChannel.Create ()); WifiHelper wifi;
wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue
("OfdmRate6Mbps"), "RtsCtsThreshold", UintegerValue (0));
devices = wifi.Install (wifiPhy, wifiMac, nodes);

if (pcap)
{
wifiPhy.EnablePcapAll (std::string ("aodv"));
}
}

void
AodvExample::InstallInternetStack ()
{
AodvHelper aodv;
// you can configure AODV attributes here using aodv.Set(name, value)
InternetStackHelper stack;
stack.SetRoutingHelper (aodv); // has effect on the next Install ()
stack.Install (nodes);
Ipv4AddressHelper address;
address.SetBase ("10.0.0.0", "255.0.0.0");
interfaces = address.Assign (devices);

if (printRoutes)
{
Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper> ("aodv.routes",
std::ios::out);
aodv.PrintRoutingTableAllAt (Seconds (8), routingStream);
}
}

void
AodvExample::InstallApplications ()
{
V4PingHelper ping (interfaces.GetAddress (size - 1));
ping.SetAttribute ("Verbose", BooleanValue (true));
 ApplicationContainer p = ping.Install (nodes.Get (0));
p.Start (Seconds (0));
p.Stop (Seconds (totalTime) - Seconds (0.001));

// move node away

Ptr<Node> node = nodes.Get (size/2);
Ptr<MobilityModel> mob = node->GetObject<MobilityModel> ();
Simulator::Schedule (Seconds (totalTime/3), &MobilityModel::SetPosition, mob, Vector (1e5,
1e5, 1e5));
}
NetAnim:

WireShark:
Q2:

Code:

#include "ns3/aodv-module.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/wifi-module.h"
#include "ns3/v4ping-helper.h"
#include "ns3/position-allocator.h"
#include "ns3/propagation-loss-model.h"
#include "ns3/applications-module.h"
#include "ns3/v4ping.h"
#include "ns3/flow-monitor-module.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-server.h"
#include <iostream>
#include <cmath>
#include <string>
#include <fstream>

using namespace ns3;

using namespace std;

/**
* \brief Test script. *
* This script creates 1-dimensional grid topology and then ping last node from the first
one:
*
* [10.0.0.1] <-- step --> [10.0.0.2] <-- step --> [10.0.0.3] <-- step --> [10.0.0.4] *
* ping 10.0.0.4
*/
class AodvExample
{
public:
AodvExample ();
/// Configure script parameters, \return true on successful configuration
bool Configure (int argc, char **argv);
/// Run simulation void Run ();
/// Report results void Report
(std::ostream & os); private:

// parameters ///
Number of nodes
uint32_t size;
/// Distance between nodes, meters
double step;
/// Simulation time, seconds
double simTime;
/// Write per-device PCAP traces if true
bool pcap;
/// Print routes if true
bool printRoutes;

string topology = "scratch/manet.csv";

double txrange = 50;

uint32_t interval = 10;

bool verbose = false;

bool tracing = true;

char* outputFilename = (char *)"manet";

// network
NodeContainer nodes;
NetDeviceContainer devices;
 Ipv4InterfaceContainer interfaces;
Address serverAddress[50];
UdpServer sermon;
YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default (); WifiMacHelper
wifiMac;

private: void CreateNodes

(); void CreateDevices ();
void InstallInternetStack ();
void InstallApplications (); };

NS_LOG_COMPONENT_DEFINE ("ManetTest");

int main (int argc, char **argv)

{
AodvExample test; if
(!test.Configure (argc, argv))
NS_FATAL_ERROR ("Configuration failed. Aborted.");

test.Run ();
test.Report (std::cout);
return 0;
}

//-----------------------------------------------------------------------------
AodvExample::AodvExample () :
size (20),
step (5),
simTime (50),
pcap (true),
printRoutes (false)
{}

bool
AodvExample::Configure (int argc, char **argv)
{
// Enable AODV logs by default. Comment this if too noisy
// LogComponentEnable("AodvRoutingProtocol", LOG_LEVEL_ALL);

SeedManager::SetSeed (12345);
CommandLine cmd;

cmd.AddValue ("pcap", "Write PCAP traces.", pcap);

cmd.AddValue ("printRoutes", "Print routing table dumps.",
printRoutes); cmd.AddValue ("size", "Number of nodes.", size);
cmd.AddValue ("simTime", "Simulation time, in seconds.", simTime);
cmd.AddValue ("outputFilename", "Output filename", outputFilename);
cmd.AddValue ("topology", "Topology file.", topology);
cmd.AddValue ("txrange", "Transmission range per node, in meters.",
txrange); cmd.AddValue ("interval", "Interval between each iteration.",
interval); cmd.AddValue ("verbose", "Verbose tracking.", verbose);
cmd.AddValue ("tracing", "Enable pcap tracing", tracing); cmd.AddValue
("outputFilename", "Output filename", outputFilename);

cmd.Parse (argc, argv);

if (verbose)
{
LogComponentEnable ("UdpSocket", LOG_LEVEL_INFO);
LogComponentEnable ("UdpServer", LOG_LEVEL_INFO);
}

return true;
}

void
AodvExample::Run ()
{
// Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", UintegerValue (1)); //
enable rts cts all the time.
CreateNodes ();
CreateDevices ();
InstallInternetStack ();
InstallApplications ();

//std::cout << "Starting simulation for " << simTime << " s ...\n";
Simulator::Stop (Seconds (simTime));
Simulator::Run ();
Simulator::Destroy ();
}

void
AodvExample::Report (std::ostream &)
{
}

void
AodvExample::CreateNodes ()
{
 std::cout << "Creating " << (unsigned)size << " nodes with transmission range " << txrange <<
"m.\n";
nodes.Create (size);
// Name nodes
for (uint32_t i = 0; i < size; ++i)
{
std::ostringstream os;
os << "node-" << i;
Names::Add (os.str (), nodes.Get (i));
}

Ptr<ListPositionAllocator> positionAllocS = CreateObject<ListPositionAllocator> ();

std::string line;
ifstream file(topology);

uint16_t i = 0;
double vec[3];

if(file.is_open())
{ while(getline(file,line)) {

//std::cout<<line<< '\n'; char

seps[] = ","; char *token;
token = strtok(&line[0], seps);
//std::cout << token << "\n";

while(token != NULL)
{
//printf("[%s]\n", token);
vec[i] = atof(token);
i++;
token = strtok (NULL, ",");
if(i == 3) {
//std::cout << "\n" << vec[0] << " " << vec[1] << " " << vec[2] << "\
n"; positionAllocS->Add(Vector(vec[1], vec[2], 0.0)); i = 0;
}
}

}
file.close();
}
 else
{
std::cout<<"Error in csv file"<< '\n'; }

MobilityHelper mobilityS;
mobilityS.SetPositionAllocator(positionAllocS);
mobilityS.SetMobilityModel("ns3::ConstantPositionMobilityModel"); //whatever it is
mobilityS.Install(nodes);
}

void
AodvExample::CreateDevices ()
{

wifiMac.SetType ("ns3::AdhocWifiMac");

YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

wifiChannel.AddPropagationLoss("ns3::RangePropagationLossModel",
"MaxRange", DoubleValue (txrange));
wifiPhy.SetChannel (wifiChannel.Create ());
WifiHelper wifi;
wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue
("OfdmRate6Mbps"), "RtsCtsThreshold", UintegerValue (0));
devices = wifi.Install (wifiPhy, wifiMac, nodes);

if (pcap)
{
wifiPhy.EnablePcapAll (std::string ("aodv"));
}
}

void
AodvExample::InstallInternetStack ()
{

AodvHelper aodv;
// you can configure AODV attributes here using aodv.Set(name, value)
InternetStackHelper stack;
stack.SetRoutingHelper (aodv); // has effect on the next Install ()
stack.Install (nodes);
Ipv4AddressHelper address;
address.SetBase ("10.0.0.0", "255.0.0.0");
 interfaces = address.Assign (devices);

for(uint32_t i = 0; i < (size / 2); i++)

{ serverAddress[i] = Address (interfaces.GetAddress (i)); }

/*
if (printRoutes)
{
Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper> ("aodv.routes",
std::ios::out);
aodv.PrintRoutingTableAllAt (Seconds (8), routingStream);
}
*/
}

void
AodvExample::InstallApplications ()
{
uint16_t i = 0;
uint16_t j = 0;
uint16_t k = 0;
//uint16_t n = 10;
uint16_t port = 4000;
UdpServerHelper server (port);
ApplicationContainer apps;

for(i = 0; i < (size / 2); i++)

{ apps = server.Install (nodes.Get (i));
}

apps.Start (Seconds (1.0));

apps.Stop (Seconds (simTime));

//Ptr<UdpServer> sermon = server.GetServer();

// Create one UdpClient application to send UDP datagrams from node zero to
// node one.

uint32_t MaxPacketSize = 1024;

Time interPacketInterval = Seconds (0.01);
uint32_t maxPacketCount = 3;
double interval_start = 2.0, interval_end = interval_start + interval;
 //std::cout << "Sending packets now.\n\n";
for(k = 1; k <= (size / 2); k++)
{
for(i = 0; i < k; i++)
{
UdpClientHelper client (serverAddress[i], port); client.SetAttribute
("MaxPackets", UintegerValue (maxPacketCount));
client.SetAttribute ("Interval", TimeValue (interPacketInterval));
client.SetAttribute ("PacketSize", UintegerValue (MaxPacketSize));
for(j = (size / 2); j < ((size / 2) + k); j++)
{
apps = client.Install (nodes.Get (j));
}
}

apps.Start (Seconds (interval_start));

apps.Stop (Seconds (interval_end));
interval_start = interval_end + 1.0;
interval_end = interval_start + interval;
}

uint32_t rxPacketsum = 0;
double Delaysum = 0; uint32_t
txPacketsum = 0; uint32_t
txBytessum = 0; uint32_t
rxBytessum = 0; uint32_t
txTimeFirst = 0; uint32_t
rxTimeLast = 0;
uint32_t lostPacketssum = 0;

FlowMonitorHelper flowmon;
Ptr<FlowMonitor> monitor = flowmon.InstallAll();

Simulator::Stop (Seconds (10.0));

//std::cout<<"Packets sent. \n";
if (tracing == true)
{
wifiPhy.EnablePcapAll (outputFilename);
//wifiPhy.EnablePcap (outputFilename, nodes.Get (0));
//csma.EnablePcap (outputFilename, csmaDevices.Get (0), true);
}
Simulator::Run ();
 k = 0;

monitor->CheckForLostPackets ();

Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier> (flowmon.GetClassifier

());
std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats ();

for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin (); i != stats.end ();

++i)
{
Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow (i->first);
rxPacketsum += i->second.rxPackets;
txPacketsum += i->second.txPackets;
txBytessum += i->second.txBytes; rxBytessum
+= i->second.rxBytes;
Delaysum += i->second.delaySum.GetSeconds();
lostPacketssum += i->second.lostPackets; txTimeFirst += i-
>second.timeFirstTxPacket.GetSeconds(); rxTimeLast += i-
>second.timeLastRxPacket.GetSeconds();

if ((t.sourceAddress < "10.0.0.101") && (t.destinationAddress < "10.0.0.101"))

{
if((i->second.txBytes >= 1000)||(i->second.rxBytes >=
1000))//&&(i>second.txBytes == i->second.rxBytes))
{ k++;

//std::cout << "Flow " << i->first << " (" << t.sourceAddress << " -> " << t.destinationAddress
<< ")\n";
//std::cout << " Tx Bytes: " << i->second.txBytes << "\n";
//std::cout << " Rx Bytes: " << i->second.rxBytes << "\n";
//std::cout << " Throughput: " << i->second.rxBytes * 8.0 / (i-
>second.timeLastRxPacket.GetSeconds() - i->second.timeFirstTxPacket.GetSeconds())/1024/1024
<< " Mbps\n";
}
}
 uint64_t timeDiff = (rxTimeLast - txTimeFirst);

//uint64_t rcvd = sermon->GetReceived();

//uint16_t lst = sermon->GetLost();
//std::cout << k << " " << " " << rxTimeLast << " " <<txTimeFirst<< "\n\n";
//std::cout<<"rec pkts"<<rxPacketsum<<"\n";

std::cout << "\n\n";

//std::cout << " Total Tx Packets: " << txPacketsum << "\n"; //std::cout << " Total Rx
Packets: " << rxPacketsum << "\n"; std::cout << " Total Packets Lost: " <<
lostPacketssum << "\n"; std::cout << " Throughput: " << ((rxBytessum * 8.0) /
timeDiff)/1024<<" Kbps"<<"\n"; std::cout << " Packets Delivery Ratio: " <<
(((txPacketsum - lostPacketssum) * 100)
/txPacketsum) << "%" << "\n";
Simulator::Destroy ();
}
Performance Comparison:

Packet Delivery Ratio VS Transmission range

Packet Delivery Ratio VS Number of Nodes

Throughput VS Transmission Range

Throughput VS Number of Nodes