e-mail address: omnetmanual@gmail.com

Phone number: +91 9444856435
DEFENDER

How to implement flooding routing in OMNeT++

To implement the Flooding routing in OMNeT++ basically this process is a modest but effective technique used in network routing where each node, upon getting a packet, forwards it to all its neighbours with the exception of the one it received the packet from. If this method is not carefully managed then also lead to redundancy and network congestion and make sure that the packer occasionally reaches all nodes in the network. Procedure is given below to implementing flooding routing in OMNeT++ using the INET framework:

Step-by-Step Implementations:

Step 1: Set Up OMNeT++ and INET Framework

  1. Install OMNeT++:
    • Make sure OMNeT++ is installed on the system.
  2. Install the INET Framework:
    • Download and install the INET Framework, which offers various networking protocols and models. INET can be downloaded from the INET GitHub repository.

Step 2: Create a New OMNeT++ Project

  1. Create the Project:
    • Open OMNeT++ and to build a new OMNeT++ project by File > New > OMNeT++ Project.
    • Name the project like FloodingRoutingSimulation and set up the project directory.
  2. Set Up Project Dependencies:
    • Make certain the project references the INET Framework by right-clicking on the project in the Project Explorer, directing to Properties > Project References, and verifying the INET project.

Step 3: Define the Network Topology

  1. Create a NED File:
    • Define the network topology using the NED language. This topology will include nodes or routers that will employ flooding routing.

Example:

network FloodingNetwork

{

submodules:

node1: StandardHost;

node2: StandardHost;

node3: StandardHost;

node4: StandardHost;

connections:

node1.ethg++ <–> Eth10Mbps <–> node2.ethg++;

node2.ethg++ <–> Eth10Mbps <–> node3.ethg++;

node3.ethg++ <–> Eth10Mbps <–> node4.ethg++;

node4.ethg++ <–> Eth10Mbps <–> node1.ethg++;

}

  1. Configure Network Parameters:
    • Set up the required link parameters like bandwidth, delay, and packet loss to simulate a realistic network situation.

Step 4: Implement the Flooding Routing Protocol

  1. Define the Flooding Routing Module:
    • Make a new module in NED for the flooding routing protocol. This module will handle packet forwarding based on the flooding routing strategy.

Example (in NED):

simple FloodingRouting

{

parameters:

@display(“i=block/network2”);

gates:

inout lowerLayerIn[];

inout lowerLayerOut[];

}

  1. Implement Flooding Routing Logic in C++:
    • Implement the routing logic in C++ that pass on incoming packets to all neighbours excepting the one it received the packet from.

Example (C++ implementation):

#include “inet/common/INETDefs.h”

#include “inet/networklayer/ipv4/IPv4Datagram.h”

#include “inet/networklayer/contract/IInterfaceTable.h”

class FloodingRouting : public cSimpleModule

{

protected:

virtual void initialize() override;

virtual void handleMessage(cMessage *msg) override;

std::map<int, std::set<long>> seenPackets;  // Track packets that have been seen

};

Define_Module(FloodingRouting);

void FloodingRouting::initialize() {

// Initialization code, if any

}

void FloodingRouting::handleMessage(cMessage *msg) {

IPv4Datagram *packet = check_and_cast<IPv4Datagram *>(msg);

int arrivalGateIndex = msg->getArrivalGate()->getIndex();

// Check if the packet has been seen before

long packetId = packet->getId();

if (seenPackets[arrivalGateIndex].find(packetId) != seenPackets[arrivalGateIndex].end()) {

// Packet already seen on this interface, drop it

delete msg;

return;

}

// Mark the packet as seen on this interface

seenPackets[arrivalGateIndex].insert(packetId);

// Flood the packet to all other interfaces

for (int i = 0; i < gateSize(“lowerLayerOut”); i++) {

if (i != arrivalGateIndex) {

cMessage *copy = packet->dup();

send(copy, “lowerLayerOut”, i);

}

}

// Delete the original message after flooding

delete msg;

}

    • Seen Packets Tracking: The module keeps track of packets that have previously been seen on each interface to keep away the infinite loops.
    • Flooding Logic: Upon receiving a packet, the module forwards it to all other interfaces not including the one it came from.

Step 5: Set Up the Simulation

  1. Configure the Simulation in omnetpp.ini:
  • Set up the simulation parameters, like traffic patterns, network settings, and simulation time.

Example:

[General]

network = FloodingNetwork

sim-time-limit = 100s

# Enable scalar and vector recording for analysis

**.scalar-recording = true

**.vector-recording = true

# Application traffic configuration (if needed)

*.node1.numApps = 1

*.node1.app[0].typename = “UdpBasicApp”

*.node1.app[0].destAddress = “255.255.255.255”  // Broadcast address

*.node1.app[0].destPort = 5000

*.node1.app[0].messageLength = 1024B

*.node1.app[0].sendInterval = uniform(1s, 2s)

  1. Traffic Configuration:
    • Set up application-level traffic among nodes to generate network activity, triggering the flooding routing.

Step 6: Run the Simulation

  1. Compile the Project:
    • Make sure everything is correctly implemented and compiled.
  2. Run Simulations:
    • Perform the simulations using OMNeT++’s IDE or command line. Note the behaviour of the flooding routing protocol, particularly how packets are transmitted over the network.

Step 7: Analyze the Results

  1. Monitor Network Traffic:
    • Assess how the flooding protocol affects network traffic, especially in terms of redundancy and congestion.
  2. Evaluate Protocol Performance:
    • Evaluate key performance metrics like network load, delay, and packet delivery ratio.
    • Scalars and Vectors: Use OMNeT++ tools to record and analyse scalar and vector data, like the number of packets forwarded and the time taken to achieve all nodes.
  3. Check for Issues:
    • Consider for issues like excessive redundancy, which can lead to network congestion.

Step 8: Refine and Optimize the Protocol

  1. Address Any Issues:
    • If the protocol exhibits issues, consider implementing optimizations like hop limits (TTL) or selective flooding to decrease redundancy.
  2. Optimize for Performance:
    • Fine-tune parameters like flooding frequency or the conditions under which flooding occurs to develop network efficiency.
  3. Re-Test:
    • Run the simulation again with the enhanced protocol to validate improvements.

This paper elaborately demonstrate how to build OMNeT++ project, generate network topology and its protocol to execute the Flooding Routing in OMNeT++. Get best simulation results on Flooding Routing in OMNeT++ tool from our writers.

Related Topics