How to Start Flooding Routing Projects Using NS3

To start a Flooding Routing project in NS3 that needs to replicate a simple routing method in which packets are sent to all neighbors apart from sender. This approach is frequently utilised in network discovery, broadcasting control messages, or portion of protocols such as AODV and DSR.

Following is a common method on how to execute the flooding routing in NS3:

Steps to Start Flooding Routing Project in NS3

  1. Understand Flooding Routing

What is Flooding Routing?

Flooding routing, from a source node transmits a packet to all their instant neighbors that then send it to its neighbors, and the like it proceed, while waiting for all nodes obtain the packet. Although simple and flooding can trigger issues such as:

  • Redundant Transmissions: Several copies of the similar packet to attain the same node.
  • Broadcast Storms: Devastating network traffic by reason of excessive forwarding.

Applications:

  • Network Discovery: It is utilized to determine the nodes within a network.
  • Broadcasting Control Messages: Broadcast routing updates or alerts.
  1. Set Up NS3

Install NS3:

  • Go to nsnam.org to download and install NS3 on the system.
  • Confirm installation to utilize below command:

./waf –run scratch/test-example

Required Modules:

  • internet: It is supports for basic networking support.
  • point-to-point, wifi, or csma: For making network topologies, these module used.
  1. Plan Your Flooding Simulation

Objectives:

  • To execute a flooding routing protocol.
  • Measure their behavior within scenarios like network discovery or broadcasting.

Example Topology:

  • A basic multi-hop network:

Node A ↔ Node B ↔ Node C ↔ Node D

↘       ↘       ↘

Node E ↔ Node F

Metrics to Evaluate:

  • Flooding Overhead: We estimate the volume of duplicate packets.
  • Reachability: Assess the rate of nodes to obtain the broadcast.
  • Latency: Estimate how long it takes time to distribute the packets to every node.
  1. Implement Flooding Routing

Step 1: Create a Flooding Application

We execute a custom application, replicating the flooding routing.

Flooding Application Code:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/applications-module.h”

using namespace ns3;

class FloodingApp : public Application {

public:

FloodingApp();

virtual ~FloodingApp();

void Setup(Address address);

private:

virtual void StartApplication();

virtual void StopApplication();

void SendFloodingPacket();

void ReceivePacket(Ptr<Socket> socket);

Ptr<Socket>  m_socket;

Address      m_peerAddress;

std::set<uint32_t> m_receivedPackets; // Track received packets to avoid duplicates

uint32_t     m_packetId; // Unique ID for packets

};

FloodingApp::FloodingApp() : m_socket(0), m_packetId(0) {}

FloodingApp::~FloodingApp() {

m_socket = 0;

}

void FloodingApp::Setup(Address address) {

m_peerAddress = address;

}

void FloodingApp::StartApplication() {

m_socket = Socket::CreateSocket(GetNode(), UdpSocketFactory::GetTypeId());

m_socket->Bind(InetSocketAddress(Ipv4Address::GetAny(), 9999));

m_socket->SetRecvCallback(MakeCallback(&FloodingApp::ReceivePacket, this));

// Send the first flooding packet

Simulator::Schedule(Seconds(1.0), &FloodingApp::SendFloodingPacket, this);

}

void FloodingApp::StopApplication() {

if (m_socket) {

m_socket->Close();

m_socket = 0;

}

}

void FloodingApp::SendFloodingPacket() {

Ptr<Packet> packet = Create<Packet>();

uint32_t packetId = m_packetId++;

packet->AddPacketTag(PacketIdTag(packetId));

m_socket->SendTo(packet, 0, InetSocketAddress(Ipv4Address(“255.255.255.255”), 9999));

NS_LOG_INFO(“FloodingApp: Node ” << GetNode()->GetId() << ” sent packet with ID ” << packetId);

}

void FloodingApp::ReceivePacket(Ptr<Socket> socket) {

Ptr<Packet> packet;

Address from;

while ((packet = socket->RecvFrom(from))) {

uint32_t packetId;

packet->PeekPacketTag(PacketIdTag(packetId));

if (m_receivedPackets.find(packetId) == m_receivedPackets.end()) {

// First time receiving this packet

m_receivedPackets.insert(packetId);

NS_LOG_INFO(“FloodingApp: Node ” << GetNode()->GetId() << ” received packet with ID ” << packetId);

// Forward the packet to neighbors

m_socket->SendTo(packet, 0, InetSocketAddress(Ipv4Address(“255.255.255.255”), 9999));

} else {

NS_LOG_INFO(“FloodingApp: Node ” << GetNode()->GetId() << ” dropped duplicate packet with ID ” << packetId);

}

}

}

Step 2: Use the Flooding Application in a Simulation

Main Simulation Script:

int main(int argc, char *argv[]) {

NodeContainer nodes;

nodes.Create(6);

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

p2p.SetChannelAttribute(“Delay”, StringValue(“5ms”));

NetDeviceContainer devices;

for (uint32_t i = 0; i < nodes.GetN() – 1; ++i) {

devices.Add(p2p.Install(nodes.Get(i), nodes.Get(i + 1)));

}

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper ipv4;

ipv4.SetBase(“10.1.1.0”, “255.255.255.0”);

ipv4.Assign(devices);

// Install the FloodingApp on all nodes

for (uint32_t i = 0; i < nodes.GetN(); ++i) {

Ptr<FloodingApp> app = CreateObject<FloodingApp>();

app->Setup(InetSocketAddress(Ipv4Address(“255.255.255.255”), 9999));

nodes.Get(i)->AddApplication(app);

app->SetStartTime(Seconds(1.0));

app->SetStopTime(Seconds(10.0));

}

Simulator::Run();

Simulator::Destroy();

return 0;

}

  1. Simulate and Debug

Enable Logging:

export NS_LOG=FloodingApp=level_all

./waf –run scratch/flooding-routing

Capture Packets with PCAP:

Make use of Wireshark to inspect the packet flow:

p2p.EnablePcapAll(“flooding-routing”);

  1. Evaluate Performance

Metrics to Measure:

  • Flooding Overhead:
    • Calculate the number of duplicate packets that are obtained.
  • Reachability:
    • Confirm if every node obtain the flooding message.
  • Latency:
    • Estimate the time attaining all nodes for a packet.

Use FlowMonitor:

FlowMonitorHelper flowMonitor;

Ptr<FlowMonitor> monitor = flowMonitor.InstallAll();

monitor->SerializeToXmlFile(“flooding-performance.xml”, true, true);

  1. Advanced Features
  • Controlled Flooding:
    • Restrict the flooding to utilise methods such as TTL (Time-To-Live) or Hop Count.
  • Fault Tolerance:
    • We need to replicate the link or node failures and then monitor the behaviour of flooding.
  • Energy-Aware Flooding:
    • We incorporate an energy models examining the influence over node energy consumption.
  1. Document and Visualize

Document Implementation:

  • It contains goals, techniques and outcomes.

Visualize Results:

  • Envision the packet flows to utilise NetAnim.
  • Use tools such as Matplotlib or Gnuplot, we need to plot the performance indicators.

We conducted a general approach along with sample coding on how to start and implement the Flooding Routing Projects employing the NS3 simulation platform. If you required more specific insights on this process, we will deliver in further manual.

Share your project details with us, and we’ll provide you with prompt guidance. To kick off your Flooding Routing Projects, NS3phdprojects.org is here to help you discover the most suitable project topics and simulation outcomes. We specialize in protocols like AODV and DSR. Partner with us, and you’ll witness your project results come to life.