How to Begin Implement Least Cost Routing in NS3

To begin executing Least Cost Routing within NS3 that encompasses to create a routing protocol, which determines the best path among the nodes, depends on a cost metric. The cost can be denoted factors like hop count, link delay, bandwidth, or power utilization. This method is analogous to Dijkstra’s Algorithm or Bellman-Ford Algorithm, which is utilized for determining the shortest path as cost.

Below is a common procedure to start executing Least Cost Routing in NS3:

Steps to Begin Implement Least Cost Routing in NS3

Step 1: Understand Least Cost Routing Basics

1. Key Concepts:
   • Every single node sustains a routing table including:
     • Destination: The target node.
     • Next Hop: The intermediate node attaining the destination.
     • Cost: The minimum cost to achieve the destination.
2. Algorithm Choices:
   • Dijkstra’s Algorithm: It utilizes a priority queue for determining the shortest route.
   • Bellman-Ford Algorithm: It supports to iteratively modernize routing tables according to the neighbours’ data.
3. Cost Metrics:
   • Composite parameters to integrate numerous factors.
   • Link delay, bandwidth, or energy consumption.
   • Hop count (default).
4. Workflow:
   • Set routing tables.
   • Interchange the routing data including neighbors.
   • Determine least cost paths depend on the selected metric.

Step 2: Set Up NS3

1. Install NS3:

git clone https://gitlab.com/nsnam/ns-3-dev.git

cd ns-3-dev

./ns3 configure –enable-examples –enable-tests

./ns3 build

1. Verify Installation: Execute a basic sample script to confirm the set up:

./ns3 run examples/tutorial/first

Step 3: Plan the Protocol Design

1. Core Components:
   • Routing Table: It saves data for computing the least cost paths.
   • Cost Calculation: For cost calculation, it describes the metric.
   • Path Computation: Executes the least cost algorithm such as Dijkstra’s or Bellman-Ford to determine the path.
2. Implementation Goals:
   • Replicate a network topology including weighted links.
   • Periodically interchange routing tables for calculating the least cost paths.
   • According to the computed paths, we can transmit the packets.

Step 4: Implement Least Cost Routing

Step 4.1: Define the Protocol Class

We need to prolong the Ipv4RoutingProtocol class for making the custom routing protocol:

#include “ns3/ipv4-routing-protocol.h”

#include “ns3/socket.h”

#include <map>

#include <vector>

using namespace ns3;

class LeastCostRouting : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId(void);

LeastCostRouting();

virtual ~LeastCostRouting();

virtual Ptr<Ipv4Route> RouteOutput(Ptr<Packet> packet, const Ipv4Header &header,

Ptr<NetDevice> oif, Socket::SocketErrno &sockerr) override;

virtual bool RouteInput(Ptr<const Packet> packet, const Ipv4Header &header,

Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

MulticastForwardCallback mcb, LocalDeliverCallback lcb,

ErrorCallback ecb) override;

void NotifyInterfaceUp(uint32_t interface) override;

void NotifyInterfaceDown(uint32_t interface) override;

void StartRouting();

private:

void InitializeRoutingTable();

void SendRoutingUpdates();

void ReceiveRoutingUpdates(Ptr<Socket> socket);

void ComputeLeastCostPaths();

std::map<Ipv4Address, std::pair<Ipv4Address, uint32_t>> m_routingTable; // Destination -> (NextHop, Cost)

std::map<Ipv4Address, std::map<Ipv4Address, uint32_t>> m_topology; // Link costs

Ptr<Socket> m_socket;

};

Step 4.2: Implement Core Functions

• Routing Table Initialization: Set the routing table including direct neighbors.

void LeastCostRouting::InitializeRoutingTable() {

for (uint32_t i = 0; i < GetNode()->GetNDevices(); ++i) {

Ptr<NetDevice> device = GetNode()->GetDevice(i);

Ipv4Address address = GetNode()->GetObject<Ipv4>()->GetAddress(i, 0).GetLocal();

m_routingTable[address] = {address, 0}; // Cost to itself is 0

}

}

• Send Routing Updates: Periodically transmit the routing updates to neighbors.

void LeastCostRouting::SendRoutingUpdates() {

Ptr<Packet> packet = Create<Packet>();

for (const auto &entry : m_routingTable) {

// Serialize routing table entries into packet

}

for (uint32_t i = 0; i < GetNode()->GetNDevices(); ++i) {

Ptr<NetDevice> device = GetNode()->GetDevice(i);

m_socket->SendTo(packet, 0, InetSocketAddress(Ipv4Address(“255.255.255.255”), 9999));

}

Simulator::Schedule(Seconds(10.0), &LeastCostRouting::SendRoutingUpdates, this);

}

• Compute Least Cost Paths: Determine the least cost paths with the support of Dijkstra’s Algorithm.

void LeastCostRouting::ComputeLeastCostPaths() {

std::map<Ipv4Address, uint32_t> distance;

std::map<Ipv4Address, Ipv4Address> previous;

// Initialize distances

for (const auto &node : m_topology) {

distance[node.first] = UINT32_MAX;

}

Ipv4Address source = GetNode()->GetObject<Ipv4>()->GetAddress(1, 0).GetLocal();

distance[source] = 0;

// Dijkstra’s algorithm

while (!distance.empty()) {

auto it = std::min_element(distance.begin(), distance.end(),

[](const auto &a, const auto &b) { return a.second < b.second; });

Ipv4Address current = it->first;

uint32_t currentDist = it->second;

distance.erase(it);

for (const auto &neighbor : m_topology[current]) {

uint32_t newDist = currentDist + neighbor.second;

if (newDist < distance[neighbor.first]) {

distance[neighbor.first] = newDist;

previous[neighbor.first] = current;

}

}

}

// Update routing table

for (const auto &entry : previous) {

m_routingTable[entry.first] = {entry.second, distance[entry.first]};

}

}

• Packet Forwarding: Depends on the least cost routing table, we can send packets.

Ptr<Ipv4Route> LeastCostRouting::RouteOutput(Ptr<Packet> packet, const Ipv4Header &header,

Ptr<NetDevice> oif, Socket::SocketErrno &sockerr) {

Ptr<Ipv4Route> route = Create<Ipv4Route>();

auto it = m_routingTable.find(header.GetDestination());

if (it != m_routingTable.end()) {

route->SetDestination(header.GetDestination());

route->SetGateway(it->second.first); // Next hop

route->SetOutputDevice(oif);

}

return route;

}

Step 5: Integrate Least Cost Routing into NS3

Register the Protocol:

Enrol the protocol including the TypeId system in NS3:

TypeId LeastCostRouting::GetTypeId(void) {

static TypeId tid = TypeId(“ns3::LeastCostRouting”)

.SetParent<Ipv4RoutingProtocol>()

.SetGroupName(“Internet”)

.AddConstructor<LeastCostRouting>();

return tid;

}

Simulation Script:

Configure a network topology and incorporate the protocol in simulation script:

#include “ns3/internet-stack-helper.h”

int main(int argc, char *argv[]) {

NodeContainer nodes;

nodes.Create(4);

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

p2p.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices = p2p.Install(nodes.Get(0), nodes.Get(1));

devices.Add(p2p.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(p2p.Install(nodes.Get(2), nodes.Get(3)));

InternetStackHelper stack;

Ptr<LeastCostRouting> lcr = CreateObject<LeastCostRouting>();

stack.SetRoutingHelper(lcr);

stack.Install(nodes);

Simulator::Run();

Simulator::Destroy();

return 0;

}

Step 6: Test and Debug

1. Enable Logging:

export NS_LOG=”LeastCostRouting=level_all|prefix_time”

./ns3 run my-simulation

1. Validate Results:
   • Confirm routing table updates.
   • Make sure both packet delivery and path selection.

Step 7: Extend and Optimize

1. Enhancements:
   • Integrate the support for dynamic cost parameters such as delay, bandwidth.
   • Execute loop prevention mechanisms like split horizon.
2. Performance Testing:
   • Examine the performance of least cost routing within large-scale networks.
   • Parse scalability and convergence time.

We had provided a sequential guide on how to implement and extend the Least Cost Routing using NS3 environment with relevant sample coding. Further elaboration will be available in the upcoming manual.