How to Start Hierarchical Routing Projects Using NS3

To start a Hierarchical Routing project using NS3 that has numerous steps to replicate a routing protocol, which classifies the network to clusters or zones enhancing the scalability and efficiency. Hierarchical routing minimizes the overhead of large flat routing tables by splitting the network to smaller and manageable divisions.

Here’s we see how to initiate and execute the Hierarchical Routing Projects in NS3:

Steps to Start Hierarchical Routing Projects in NS3

Understand Hierarchical Routing

What is Hierarchical Routing?

Hierarchical routing is categorizes a network to a hierarchy:

Cluster-based Routing:
- Nodes are gathered into clusters including a cluster head that are responsible for intra- and inter-cluster interaction.
Zone-based Routing:
- The network is splitted into zones including routing individually managed in and among the zones.

Benefits:

It is minimizes the routing overhead within large networks.
Enhances the effectiveness and scalability.

Common Protocols:

Zone Routing Protocol (ZRP):
- These protocol integrates the proactive and reactive routing in and over the zones.
Hierarchical OLSR (H-OLSR):
- It prolongs the OLSR including hierarchy levels for effective large-scale routing.

Set Up NS3

Install NS3

Go to nsnam.org to download and install the NS3 environment.
Then, confirm the installation:

./waf –run scratch/test-example

Required Modules

internet: It supports for IP and transport protocols.
wifi, csma, or point-to-point: For network topologies, these modules are utilized.

Plan Your Hierarchical Routing Simulation

Objectives:

To replicate the hierarchical routing for a large network.
Estimate the performance in diverse conditions like mobility, traffic load.

Example Topology:

It able to split the network into clusters or zones.
Example:

Zone 1: Node A ↔ Node B ↔ Node C (Cluster Head: B)

Zone 2: Node D ↔ Node E ↔ Node F (Cluster Head: E)

Inter-Zone Communication: B ↔ E

Metrics to Evaluate:

Routing Overhead: It manages the packet load.
Scalability: We measure the performance including increasing nodes.
Throughput, Delay, and Packet Delivery Ratio: For data traffic, we need to assess these performance metrics.

Implement Hierarchical Routing

Option 1: Custom Hierarchical Routing Protocol

Implement the own routing protocol by means of prolonging Ipv4RoutingProtocol class of NS3.

Option 2: Leverage Existing Protocols

Replicate the hierarchy to utilize built-in protocols of NS3 such as OLSR and then alter them.

4.1 Custom Hierarchical Routing Protocol

Step 1: Define a Cluster-Based Routing Protocol

Dynamically or statically, we allocate the cluster heads.
Nodes in a cluster route via its cluster head.
For inter-cluster routing, cluster heads interact with other cluster heads.

Example Code:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/applications-module.h”

using namespace ns3;

class HierarchicalRoutingApp : public Application {

public:

HierarchicalRoutingApp();

virtual ~HierarchicalRoutingApp();

void Setup(Ptr<Node> node, bool isClusterHead);

private:

virtual void StartApplication();

virtual void StopApplication();

void SendIntraCluster();

void SendInterCluster();

void ReceivePacket(Ptr<Socket> socket);

Ptr<Node> m_node;

Ptr<Socket> m_socket;

bool m_isClusterHead;

Address m_clusterHeadAddress;

};

HierarchicalRoutingApp::HierarchicalRoutingApp() : m_socket(0), m_isClusterHead(false) {}

HierarchicalRoutingApp::~HierarchicalRoutingApp() {

m_socket = 0;

}

void HierarchicalRoutingApp::Setup(Ptr<Node> node, bool isClusterHead) {

m_node = node;

m_isClusterHead = isClusterHead;

}

void HierarchicalRoutingApp::StartApplication() {

m_socket = Socket::CreateSocket(m_node, UdpSocketFactory::GetTypeId());

m_socket->Bind(InetSocketAddress(Ipv4Address::GetAny(), 9999));

m_socket->SetRecvCallback(MakeCallback(&HierarchicalRoutingApp::ReceivePacket, this));

if (m_isClusterHead) {

Simulator::Schedule(Seconds(1.0), &HierarchicalRoutingApp::SendInterCluster, this);

} else {

Simulator::Schedule(Seconds(1.0), &HierarchicalRoutingApp::SendIntraCluster, this);

}

void HierarchicalRoutingApp::StopApplication() {

if (m_socket) {

m_socket->Close();

m_socket = 0;

}

void HierarchicalRoutingApp::SendIntraCluster() {

if (!m_isClusterHead) {

Ptr<Packet> packet = Create<Packet>(100); // Intra-cluster packet

m_socket->SendTo(packet, 0, InetSocketAddress(m_clusterHeadAddress, 9999));

Simulator::Schedule(Seconds(5.0), &HierarchicalRoutingApp::SendIntraCluster, this);

}

void HierarchicalRoutingApp::SendInterCluster() {

if (m_isClusterHead) {

Ptr<Packet> packet = Create<Packet>(200); // Inter-cluster packet

// Broadcast or send to neighboring cluster heads

Simulator::Schedule(Seconds(5.0), &HierarchicalRoutingApp::SendInterCluster, this);

}

void HierarchicalRoutingApp::ReceivePacket(Ptr<Socket> socket) {

Ptr<Packet> packet;

Address from;

while ((packet = socket->RecvFrom(from))) {

NS_LOG_INFO(“Packet received at node: ” << m_node->GetId());

}

Step 2: Use the Application in a Simulation

Configure the nodes and allocate some cluster heads.
We need to install the application at every node.

4.2 Using Existing Protocols

Use OLSR for Hierarchical Routing

OLSR can prolong to hierarchical routing by allocating super nodes such as cluster heads and executing the OLSR at each hierarchy level.

#include “ns3/olsr-module.h”

OlsrHelper olsr;

InternetStackHelper stack;

stack.SetRoutingHelper(olsr);

stack.Install(nodes);

Use ZRP-like Zone-Based Routing

Zone-based protocols integrate the proactive (intra-zone) and reactive (inter-zone) routing. We can be executed this logic by incorporating the protocols such as OLSR (proactive) and AODV (reactive).

Simulate and Debug

Enable Logging:

export NS_LOG=HierarchicalRoutingApp=level_all

./waf –run scratch/hierarchical-routing

Inspect Routing Tables: Confirm routing decisions on nodes using following command:

Ptr<Ipv4> ipv4 = nodes.Get(0)->GetObject<Ipv4>();

ipv4->GetRoutingProtocol()->Print(std::cout);

Capture Packets with PCAP: Inspect packet flows including Wireshark.

p2p.EnablePcapAll(“hierarchical-routing”);

Evaluate Performance

Metrics to Measure:

Control Overhead: We estimate the number of routing data that are swapped.
Convergence Time: Measure how long it takes time for nodes modernizing the routing tables.
Scalability: We compute the performance depends on the network grows.
Data Delivery Metrics: Assess metrics like throughput, delay and packet loss.

Use FlowMonitor:

FlowMonitorHelper flowMonitor;

Ptr<FlowMonitor> monitor = flowMonitor.InstallAll();

monitor->SerializeToXmlFile(“hierarchical-routing-performance.xml”, true, true);

Advanced Features

Dynamic Topologies:
- Experiment the protocol in dynamic conditions to utilize mobility models.

MobilityHelper mobility;

mobility.SetMobilityModel(“ns3::RandomWaypointMobilityModel”);

mobility.Install(nodes);

Fault Tolerance:
- Replicate the link or node failures, monitoring the recovery mechanisms.
Energy Efficiency:
- We can insert an energy models to experiment the power-aware hierarchical routing.

Document and Visualize

Document Implementation:
- It contains project goals, methods, and outcomes.
Visualize Results:
- Envision the network to utilize NetAnim.
- We want to plot the performance indicators to utilize tools such as Matplotlib or Gnuplot.

This guide demonstrate how to start and execute the Hierarchical Routing Projects using NS3 simulation tool for simulating the routing protocol with the help of given method then analyse the performance and visualize the outcomes.

To achieve optimal project outcomes, you may rely on our specialists who will provide guidance throughout all stages of your Hierarchical Routing Projects utilizing the NS3 tool. Obtain customized support from phdprojects.org. We specialize in hierarchical routing.