e-mail address: omnetmanual@gmail.com

Phone number: +91 9444856435
DEFENDER

How to Implement benes network routing in OMNeT++

The Benes network is nothing but a clos network which is rearrangeable non-blocking network typically used in switching and communication networks. It has a infrastructure like multistage interconnection network (MIN) and can route any permutation of inputs to outputs without blocking.

To implement the benes network routing in the OMNeT++  we need to state the network topology and configure the links amongst nodes (stages) and execute the routing logic which controls how the packets move across the network. So by approaching us you can stay in touch with us for good implementation and simulation guidance.

Here’s how you can implement Beneš network routing in OMNeT++:

Step-by-Step Implementation:

Step 1: Set Up OMNeT++ and INET Framework

  1. Install OMNeT++:
    • Make certain that you have installed the OMNeT++ on your computer.
  2. Install the INET Framework:
    • Install the INET Framework, which offer many 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 create a new OMNeT++ project via File > New > OMNeT++ Project.
    • Name your project (e.g., BenesNetworkSimulation) and set up the project directory.
  2. Set Up Project Dependencies:
    • Make sure the project references the INET Framework by right-clicking on your project in the Project Explorer, navigating to Properties > Project References, and verifying the INET project.

Step 3: Define the Beneš Network Topology

  1. Understand the Beneš Network Structure:
    • A Beneš network comprises of numerous stages of switching. For an n×nn \times nn×n Beneš network, there are 2log⁡2(n)−12\log_2(n) – 12log2​(n)−1 stages, each with n/2n/2n/2 2×2 switches. The first log⁡2(n)\log_2(n)log2​(n) stages form the forward path, and the last log⁡2(n)\log_2(n)log2​(n) stages form the reverse path.
  2. Create a NED File for the Topology:
    • In the NED file, we have to state the network topology. Here, you will manually construct the Beneš network stages.

Example for a 4×4 Beneš network (with 3 stages):

network BenesNetwork

{

parameters:

int n = default(4); // Network size

submodules:

// Input stage

in0: Switch2x2;

in1: Switch2x2;

// Middle stage

mid0: Switch2x2;

mid1: Switch2x2;

// Output stage

out0: Switch2x2;

out1: Switch2x2;

// Hosts connected to the network

host[4]: StandardHost;

connections allowunconnected:

// Connections between stages (Forward Path)

in0.portOut[0] <–> Eth10Mbps <–> mid0.portIn[0];

in0.portOut[1] <–> Eth10Mbps <–> mid1.portIn[0];

in1.portOut[0] <–> Eth10Mbps <–> mid0.portIn[1];

in1.portOut[1] <–> Eth10Mbps <–> mid1.portIn[1];

// Connections between stages (Reverse Path)

mid0.portOut[0] <–> Eth10Mbps <–> out0.portIn[0];

mid0.portOut[1] <–> Eth10Mbps <–> out1.portIn[0];

mid1.portOut[0] <–> Eth10Mbps <–> out0.portIn[1];

mid1.portOut[1] <–> Eth10Mbps <–> out1.portIn[1];

// Connections to hosts

host[0].ethg++ <–> Eth10Mbps <–> in0.portIn[0];

host[1].ethg++ <–> Eth10Mbps <–> in1.portIn[0];

host[2].ethg++ <–> Eth10Mbps <–> out0.portOut[0];

host[3].ethg++ <–> Eth10Mbps <–> out1.portOut[0];

}

Step 4: Implement the Switch Module (2×2 Switch)

  1. Create a 2×2 Switch Module:
    • Execute the switch which will be used in the Beneš network. Every switch has two input ports and two output ports, and depends on the routing logic, it can.

Example (in NED):

simple Switch2x2

{

parameters:

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

gates:

inout portIn[2];  // Two input ports

inout portOut[2]; // Two output ports

}

  1. Implement the Routing Logic in C++:
    • Implement the logic in C++ that defines how packets are forwarded across the switch.

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 Switch2x2 : public cSimpleModule

{

protected:

virtual void initialize() override;

virtual void handleMessage(cMessage *msg) override;

void forwardPacket(cPacket *packet, int inputGateIndex);

};

Define_Module(Switch2x2);

void Switch2x2::initialize() {

// Initialization code here

}

void Switch2x2::handleMessage(cMessage *msg) {

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

int inputGateIndex = packet->getArrivalGate()->getIndex();

forwardPacket(packet, inputGateIndex);

}

void Switch2x2::forwardPacket(cPacket *packet, int inputGateIndex) {

// Implement routing logic

// Example: If the packet arrives on portIn[0], send it to portOut[0], and vice versa

int outputGateIndex = (inputGateIndex == 0) ? 0 : 1;

send(packet, “portOut”, outputGateIndex);

}

    • Routing Logic: The above logic simply forwards packets from one input port to the corresponding output port. We can alter this logic to generate certain routing paths depending on the network traffic.

Step 5: Configure the Simulation

  1. Set Up the Simulation in omnetpp.ini:
    • State the simulation parameters like the network to use, simulation time, and traffic generation between the hosts.

Example:

network = BenesNetwork

sim-time-limit = 100s

**.scalar-recording = true

**.vector-recording = true

# Traffic generation (e.g., UDP traffic between hosts)

*.host[0].numApps = 1

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

*.host[0].app[0].destAddress = “host[2]”

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

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

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

*.host[1].numApps = 1

*.host[1].app[0].typename = “UdpBasicApp”

*.host[1].app[0].destAddress = “host[3]”

*.host[1].app[0].destPort = 5000

*.host[1].app[0].messageLength = 1024B

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

  1. Compile and Run the Simulation:
    • Make sure everything is properly implemented and compiled. Run the simulation using OMNeT++’s IDE or command line.

Step 6: Analyze the Results

  1. Monitor Network Behavior:
    • Monitor how packets are routed via Beneš network. Check whether the network correctly routes packets from the inputs to the outputs according to the routing logic.
  2. Evaluate Performance:
    • Evaluate key performance metrics like packet delivery ratio, end-to-end delay, and network throughput.
    • Scalars and Vectors: Use OMNeT++ tools to record and analyze scalar and vector data like the amount of packets sent, received, and dropped, as well as the time taken to deliver packets.

Step 7: Optimize and Extend the Network

  1. Address Any Issues:
    • If the simulation reveals any issues (e.g., incorrect routing, packet loss), fine-tune the routing logic or network configuration as needed.
  2. Extend the Network:
    • Encompass the Beneš network to help more inputs and outputs or add more difficult traffic patterns to analyze its performance.

As we discussed earlier in this report, it will help you to set up the simulation network and to implement the benes network routing in the OMNeT++ environment. If needed, we can help you with another approach of other simulation networks.

Related Topics