e-mail address: omnetmanual@gmail.com

Phone number: +91 9444856435
DEFENDER

How to Implement hot potato routing in OMNeT++

To implement the Hot potato routing in OMNeT++, is well-known as deflection routing or “best-effort” routing, is an approach where every packet is forwarded without delay without holding it in a storage area to the next available output port.  This method is frequently used in situations where buffering is luxurious or inaccessible.  The main target is to reduce packet delay by speedily passing packets over the network, if the selected path is not ideal.

To implement the hot potato routing in OMNeT++ using the INET framework encompasses to forming a custom routing module that move onwards packets to the closest available link without regarding as the long-term optimality of the route. Given below is a step-by-step procedure is helpful to implement hot potato routing.

Step-by-Step Implementations:

Step 1: Set Up OMNeT++ and INET Framework

  1. Install OMNeT++:
    • Make sure OMNeT++ is installed on the system. Download it from the  OMNeT++
  2. Install the INET Framework:
    • Download and install the INET Framework, which gives different 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 make a new OMNeT++ project through File > New > OMNeT++ Project.
    • Name your project like HotPotatoRoutingSimulation 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, the way to Properties > Project References, and verifying the INET project.

Step 3: Define the Network Topology

  1. Create a NED File:
    • Describe the network topology using the NED language. This topology will contain routers and hosts that will use hot potato routing.

Example:

network HotPotatoRoutingNetwork

{

submodules:

router1: Router {

@display(“p=100,200”);

}

router2: Router {

@display(“p=300,200”);

}

router3: Router {

@display(“p=200,300”);

}

router4: Router {

@display(“p=400,200”);

}

host1: StandardHost {

@display(“p=50,350”);

}

host2: StandardHost {

@display(“p=450,350”);

}

connections allowunconnected:

router1.ethg++ <–> Eth10Gbps <–> router2.ethg++;

router2.ethg++ <–> Eth10Gbps <–> router3.ethg++;

router3.ethg++ <–> Eth10Gbps <–> router4.ethg++;

router1.ethg++ <–> Eth10Gbps <–> router3.ethg++;

router2.ethg++ <–> Eth10Gbps <–> router4.ethg++;

router1.ethg++ <–> Eth10Gbps <–> host1.ethg++;

router4.ethg++ <–> Eth10Gbps <–> host2.ethg++;

}

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

Step 4: Implement the Hot Potato Routing Protocol

  1. Define the Hot Potato Routing Module:
    • To make a fresh module in NED for the hot potato routing algorithm. This module will manage the forwarding of packets to the next accessible link.

Example (in NED):

simple HotPotatoRouting

{

parameters:

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

gates:

inout lowerLayerIn[];

inout lowerLayerOut[];

}

  1. Implement Hot Potato Routing Logic in C++:
    • Implement the routing logic in C++ that forwards packets instantly to the ensuing available link without buffering.

Example (C++ implementation):

#include “inet/common/INETDefs.h”

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

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

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

#include “inet/queueing/contract/IPacketQueue.h”

class HotPotatoRouting : public cSimpleModule

{

private:

IRoutingTable *inetRoutingTable;

protected:

virtual void initialize() override;

virtual void handleMessage(cMessage *msg) override;

void forwardPacket(cPacket *packet);

};

Define_Module(HotPotatoRouting);

void HotPotatoRouting::initialize() {

inetRoutingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);

}

void HotPotatoRouting::handleMessage(cMessage *msg) {

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

forwardPacket(packet);

}

void HotPotatoRouting::forwardPacket(cPacket *packet) {

// Find the next available output gate

int numGates = gateSize(“lowerLayerOut”);

int selectedGateIndex = intuniform(0, numGates – 1); // Randomly select an output gate

// Forward the packet through the selected gate

send(packet, “lowerLayerOut”, selectedGateIndex);

}

    • Packet Forwarding: The forwardPacket function forwards packets instantly over the first obtainable output gate. A random output gate is select to forward the packet, mimicking the “hot potato” effect in the given example.
    • No Buffering: Different traditional routing, packets are not buffered. They are sent out once they arrive.

Step 5: Set Up the Simulation

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

Example:

[General]

network = HotPotatoRoutingNetwork

sim-time-limit = 100s

**.scalar-recording = true

**.vector-recording = true

# Configure Hot Potato Routing

*.router*.ipv4.routingTable.routingProtocol = “HotPotatoRouting”

  1. Traffic Configuration:
    • Configure the traffic patterns, like UDP or TCP applications running on the hosts, to make network activity and test the hot potato routing.

Step 6: Run the Simulation

  1. Compile the Project:
    • Make sure everything is correctly implemented and compiled.
  2. Run Simulations:
    • Execute the simulations using OMNeT++’s IDE or command line. Note that how hot potato routing directs packets through the network.

Step 7: Analyse the Results

  1. Monitor Routing Behaviour:
    • Without buffering we calculate how packets are forwarded instantly.  Validate that packets are sent to the next accessible link, even if it is not the maximum optimal route.
  2. Evaluate Performance:
    • Calculate key performance metrics like packet delivery ratio, end-to-end delay, and the effects of the deflection routing strategy.
    • Scalars and Vectors: To record and analyse scalar and vector data, such as the number of packets sent, received, and dropped, along with the time taken to deliver packets by using OMNeT++ tools.
  3. Check for Issues:
    • Verify the issues like packet loss, routing loops, or increased delay that may specify problems with the hot potato routing execution.

Step 8: Refine and Optimize the Implementation

  1. Address Any Issues:
    • Based on the simulation results to change the hot potato routing algorithm or network configuration to optimize enactment.
  2. Re-Test:
    • Run the simulation again with the enhanced configuration to support improvements.

In this module, we are discussed the step-by-step process and further details to implement the Hot Potato Routing in OMNeT++. We will furnish additional information as per your specifications on your projects with simulation and project execution guidance..

Related Topics