How to Start Path Vector Routing Projects Using OMNeT++

To start a Path Vector Routing project using OMNeT++, we can execute or replicate a routing protocol that stimulated by the principles which is frequently utilised in Path Vector Protocols such as Border Gateway Protocol (BGP). Path vector routing is created for networks including hierarchical or autonomous systems (AS) in which every single node broadcasts the entire path to destinations instead of the cost.

We follow these steps to get started:

Steps to Start Path Vector Routing Projects in OMNeT++

1. Understand Path Vector Routing

Key Features

• Every single node sustains a routing table, which saves:
  • The path which is sequence of nodes to each destination.
  • Parameters such as hop count or policy preferences.
• Nodes swap path data including neighbors.
• It avoids routing loops by means of eliminating paths, which has advertising node.

Applications

• It appropriate for hierarchical networks or scenarios including several domains like inter-AS routing.

Algorithm

• Once a node obtains a route update from a neighbor:
  • It verifies if the node is already within the path for loop prevention.
  • It modernizes their routing table depends on the advertised paths and strategies.

2. Set Up the Environment

Install OMNeT++

• We should download and install OMNeT++ on the system.
• Make sure that OMNeT++ is properly set up and works by executing sample simulations.

Install INET Framework

• We should install the INET framework which supports OMNeT++ version.
• Constrcut the framework:

make makefiles

make

3. Plan Your Simulation

Define Objectives

• We execute the Path Vector Routing for:
  • Loop prevention.
  • Routing table convergence.
  • Performance analysis for routing overhead, path optimality.

Define Network Topology

• Make a network topology including:
  • Several autonomous systems (AS) or domains.
  • Border nodes, which swap routing data.

4. Create a New OMNeT++ Project

1. In OMNeT++ IDE.
2. Select File > New > OMNeT++ Project.
3. Name it to the project like PathVectorRouting and choose Finish.

5. Implement Path Vector Routing

Create a Custom Routing Module

1. Make a new .cc file as PathVectorRouting.cc.
2. Execute the path vector logic:

Example: Path Vector Routing Logic

#include <omnetpp.h>

#include <map>

#include <vector>

using namespace omnetpp;

class PathVectorRouting : public cSimpleModule {

private:

struct Route {

std::vector<int> path; // Sequence of nodes in the path

double metric;         // Cost metric (e.g., hop count)

};

std::map<int, Route> routingTable; // Destination to route mapping

std::vector<int> neighbors;        // List of neighbors

protected:

virtual void initialize() override {

int nodeId = getId();

// Initialize routing table with self

routingTable[nodeId] = {{nodeId}, 0}; // Path to self, cost 0

}

virtual void handleMessage(cMessage *msg) override {

auto packet = check_and_cast<PathVectorPacket *>(msg);

updateRoutingTable(packet->getPath(), packet->getMetric());

delete packet;

}

void updateRoutingTable(const std::vector<int>& path, double metric) {

int destination = path.back();

int nodeId = getId();

// Check for loops

if (std::find(path.begin(), path.end(), nodeId) != path.end()) {

EV << “Loop detected. Ignoring path.\n”;

return;

}

// Calculate new metric

double newMetric = metric + 1; // Example: Increment hop count

// Update routing table if the new path is better

if (routingTable.find(destination) == routingTable.end() ||

routingTable[destination].metric > newMetric) {

routingTable[destination] = {path, newMetric};

routingTable[destination].path.push_back(nodeId); // Add self to path

broadcastRoutingTable();

}

}

void broadcastRoutingTable() {

for (int neighbor : neighbors) {

for (const auto& [destination, route] : routingTable) {

auto packet = new PathVectorPacket(“PathVectorUpdate”);

packet->setPath(route.path);

packet->setMetric(route.metric);

send(packet, “out”, neighbor);

}

}

}

};

Define_Module(PathVectorRouting);

6. Define Network Topology

Create a .ned File

Make a network topology including numerous domains or autonomous systems:

network PathVectorNetwork {

submodules:

node[6]: StandardHost {

parameters:

@display(“i=device/router”);

routingProtocol = “PathVectorRouting”;

}

connections:

node[0].pppg++ <–> { delay = 10ms; datarate = 1Gbps; } <–> node[1].pppg++;

node[1].pppg++ <–> { delay = 20ms; datarate = 1Gbps; } <–> node[2].pppg++;

node[2].pppg++ <–> { delay = 15ms; datarate = 1Gbps; } <–> node[3].pppg++;

node[3].pppg++ <–> { delay = 10ms; datarate = 1Gbps; } <–> node[4].pppg++;

node[4].pppg++ <–> { delay = 10ms; datarate = 1Gbps; } <–> node[5].pppg++;

}

7. Configure Simulation Parameters

Edit omnetpp.ini

Define simulation metrics using .ini file:

[Config PathVectorRoutingSimulation]

network = PathVectorNetwork

**.node[*].routingProtocol = “PathVectorRouting”

simulation.timeLimit = 100s

8. Run the Simulation

1. Execute the simulation to utilise Tkenv or Cmdenv.
2. Monitor:
   • Path advertisements among the nodes.
   • Routing table modernizes at each node.

9. Analyze Results

Metrics to Evaluate

• Convergence Time:
  • Calculate the duration for every node to become stable its routing tables.
• Routing Overhead:
  • Estimate the volume of routing updates that are swapped.
• Path Optimality:
  • We have to equate the paths which are made including theoretical optimal paths.

Visualization

• Observe the routing updates and packet flow with the support of OMNeT++ tools.
• Transfer records into external tools like MATLAB, Python, or Excel for in-depth analysis.

10. Extend and Optimize

Add Features

• Policy-Based Routing:
  • Integrate the support for routing preferences or constraints like prevent specific nodes or AS.
• Dynamic Cost Metrics:
  • Modify the routes to utilise the parameters such as bandwidth, latency, or congestion.

Handle Dynamic Scenarios

• Launch link or node failures to experiment the robustness of protocol.
• Mimic mobility for dynamic topologies.

Comparison with Other Protocols

• Replicate and equate the Path Vector Routing including other protocols such as Distance Vector and Link-State Routing.

Using OMNeT++, we developed an essential simulation steps for Path Vector Routing projects, which were replicated and executed. We can ready to provide more in-depth details about this topic if necessary.

Get in touch with phdprojects.org for best research guidance in your project. Path Vector Protocols like Border Gateway Protocol (BGP) are exclusively handled by us. Send us all your project details for more support.