How to Implement Temporally Ordered Routing Algorithm OMNeT
To implement the TORA routing in OMNeT++, we have numerous steps to follow. Basically the TORA is a complex task as it encompasses numerous components that contain the route creation, route maintenance, and route erasure. The term the Temporally-Ordered Routing Algorithm (TORA) is a highly adaptive, loop-free, and distributed routing protocol that planned for mobile ad hoc networks (MANETs) and it is specifically appropriate for networks where the topology changes recurrently. TORA is based on the concept of directed acyclic graphs (DAGs) rooted at the destination, which supports to guarantee that packets flow in a loop-free manner towards the destination.
The given below is the step-by-procedures on how to implement TORA in OMNeT++ using the INET framework.
Step-by-Step Implementation:
Step 1: Set Up OMNeT++ and INET Framework
- Install OMNeT++:
- Ensure OMNeT++ is installed on system. We should download it from theOMNeT++
- Install the INET Framework:
- Download and install the INET Framework, which delivers several networking protocols and models. INET can be downloaded from the INET GitHub repository.
Step 2: Create a New OMNeT++ Project
- Create the Project:
- Open OMNeT++ and create a new OMNeT++ project through File > New > OMNeT++ Project.
- Name project such as TORARoutingSimulation and set up the project directory.
- Set Up Project Dependencies:
- Make sure the project references the INET Framework by right-clicking on project in the Project Explorer, navigating to Properties > Project References, and validating the INET project.
Step 3: Define the Network Topology
- Create a NED File:
- Describe the network topology using the NED language. This topology will contain mobile or stationary nodes that will use the TORA routing protocol.
Example:
network TORANetwork
{
submodules:
host[4]: StandardHost {
@display(“p=100,200;i=block/host”);
}
connections allowunconnected:
host[0].ethg++ <–> AdhocWirelessNic <–> host[1].ethg++;
host[1].ethg++ <–> AdhocWirelessNic <–> host[2].ethg++;
host[2].ethg++ <–> AdhocWirelessNic <–> host[3].ethg++;
host[3].ethg++ <–> AdhocWirelessNic <–> host[0].ethg++;
}
- Configure Network Parameters:
- Set up necessary link performance metrics like bandwidth, delay, and mobility (if applicable) to mimic a realistic network environment.
Step 4: Implement the TORA Routing Protocol
Since INET does not offer a ready-made execution of TORA, we need execute it from scratch. Here’s how we can approach it:
- Define the TORA Module:
- Generate a new module in NED for TORA. This module will manage the routing logic.
Example (in NED):
simple TORA
{
parameters:
@display(“i=block/routing”);
gates:
inout lowerLayerIn[];
inout lowerLayerOut[];
}
- Implement TORA in C++:
- To execute the core components of TORA in C++ contains route creation, maintenance, and erasure.
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/networklayer/common/L3Address.h”
class TORA : public cSimpleModule
{
private:
IRoutingTable *inetRoutingTable;
std::map<L3Address, int> heights; // Heights for destinations
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void createRoute(const L3Address& destAddr);
void maintainRoute(const L3Address& destAddr);
void eraseRoute(const L3Address& destAddr);
void forwardPacket(cPacket *packet, const L3Address& destAddr);
};
Define_Module(TORA);
void TORA::initialize() {
inetRoutingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);
// Initialize TORA-specific variables
}
void TORA::handleMessage(cMessage *msg) {
cPacket *packet = check_and_cast<cPacket *>(msg);
L3Address destAddr = packet->getContextPointer(); // Assuming the packet contains the destination address in its context
if (/* condition to check if route exists */) {
forwardPacket(packet, destAddr);
} else {
createRoute(destAddr);
forwardPacket(packet, destAddr);
}
}
void TORA::createRoute(const L3Address& destAddr) {
// Implement the route creation process in TORA
// Establish a directed acyclic graph (DAG) towards the destination
heights[destAddr] = 0; // Example: Set initial height
}
void TORA::maintainRoute(const L3Address& destAddr) {
// Implement the route maintenance process in TORA
// Adjust the DAG based on network topology changes
}
void TORA::eraseRoute(const L3Address& destAddr) {
// Implement the route erasure process in TORA
// Remove the DAG associated with the destination
heights.erase(destAddr);
}
void TORA::forwardPacket(cPacket *packet, const L3Address& destAddr) {
// Forward the packet towards the destination based on the current DAG
// Choose the neighbor with the smallest height that is lower than the current node’s height
int currentHeight = heights[inetRoutingTable->getRouterId()];
int nextHop = -1;
// Find the next hop
for (int i = 0; i < gateSize(“lowerLayerOut”); i++) {
int neighborHeight = /* get neighbor’s height */;
if (neighborHeight < currentHeight) {
nextHop = i;
break;
}
}
if (nextHop != -1) {
send(packet, “lowerLayerOut”, nextHop);
} else {
delete packet; // Drop the packet if no suitable next hop is found
}
}
-
- Route Creation: To execute the route creation logic where the heights for each destination are initialized and used to found a directed acyclic graph (DAG).
- Route Maintenance: To apply the logic to preserve routes, regulating the DAG structure when network topology changes occur.
- Route Erasure: Implement the logic to erase routes when they are no longer needed or when a link failure occurs.
Step 5: Set Up the Simulation
- Configure the Simulation in omnetpp.ini:
- Set up the simulation parameters, like simulation time, network settings, and traffic patterns.
Example:
network = TORANetwork
sim-time-limit = 100s
**.scalar-recording = true
**.vector-recording = true
# Configure TORA routing protocol
**.host*.ipv4.routingTable.routingProtocol = “TORA”
- Traffic Configuration:
- Configure the traffic patterns like UDP or TCP applications running on the hosts, to make network activity and test the TORA routing.
Step 6: Run the Simulation
- Compile the Project:
- Make sure everything is correctly executed and compiled.
- Run Simulations:
- Execute the simulations using OMNeT++’s IDE or command line. Monitor how TORA manages routes in the network, specifically how it handles route creation, maintenance, and erasure.
Step 7: Analyse the Results
- Monitor TORA Behaviour:
- Measure how TORA manage network changes and make sure loop-free routing through its DAG-based approach.
- Evaluate Performance:
- Evaluate the key performance metrics like packet delivery ratio, end-to-end delay, and route stability.
- Scalars and Vectors: Use OMNeT++ tools to record and measure scalar and vector data, like the number of routes created, maintained, and erased, as well as packet delivery statistics.
- Check for Issues:
- Look for issues like routing loops, packet loss, or route instability that may indicate issues with the TORA implementation.
Step 8: Refine and Optimize the Implementation
- Address Any Issues:
- Regulate the TORA algorithm or network configuration based on the simulation outcomes to improve performance.
- Re-Test:
- Run the simulation again with the optimized configuration to verify the enhancement.
As we discussed earlier about how the TORA routing will perform in OMNeT++ simulator tool and we help to provide further information about how the TORA routing will adapt in diverse scenarios. You can get help with the Temporally Ordered Routing Algorithm in OMNeT++ from our developers. Just send us your project details, and we will provide guidance on topics and steps to execute.