How to Implement ABR Protocol in NS2

 

To implement the Associative-Based Routing (ABR) protocol within NS2 has needs to contain generating a routing protocol that determines routes according to the stability of nodes in the mobile ad hoc networks (MANETs). This protocol is concentrate on choosing paths with the most stable links that is ascertained by the “associativity” of the nodes, or how long they have been in a specific area. If you want to explore more in this area you can contact us we will provide you with best implementation guidance. In the below, we offered the entire implementation of ABR protocol in ns2:

Step-by-Step Implementation:

Step 1: Understand the ABR Protocol

ABR protocol is created to reduce the frequency of route discoveries by choosing stable routes according to the association stability of the nodes. The important concepts contain:

  • Associativity: An amount of how long a node has been in a specific area.
  • Route Discovery: Same to AODV, however including a preference for routes with higher associativity.
  • Route Maintenance: Detecting and responding to link breaks by the rediscovering stable routes.

Step 2: Set Up NS2

Make sure that NS2 is installed on the computer. We can download it from the NS2 webpage and pursue the installation instructions. Check the installation by running a simple simulation.

Step 3: Implement the ABR Protocol

  1. Create the ABR Agent Class (C++)

We can require to make a new C++ class in the NS2 that executes the ABR logic. This agent class should manage the following:

  • Route Discovery: Same to AODV but with a concentre on associativity metrics.
  • Route Maintenance: Maintaining routes according to the stability of nodes.

Now, we given below is a simple structure:

#include <agent.h>

#include <packet.h>

#include <trace.h>

#include <address.h>

#include <map>

class ABRAgent : public Agent {

public:

ABRAgent();

void recv(Packet* p, Handler* h);

void discoverRoute(int dest);

void forwardPacket(Packet* p);

void updateAssociativity(int nodeId);

void handleLinkBreak();

protected:

std::map<int, int> routingTable_; // Destination -> Next Hop

std::map<int, int> associativityTable_; // Node ID -> Associativity

};

// Constructor

ABRAgent::ABRAgent() : Agent(PT_UDP) {

// Initialization code here

}

// Packet reception

void ABRAgent::recv(Packet* p, Handler* h) {

hdr_ip* iph = hdr_ip::access(p);

int dest = iph->dst();

if (routingTable_.find(dest) != routingTable_.end()) {

forwardPacket(p);

} else {

discoverRoute(dest);

}

}

// Route discovery with associativity consideration

void ABRAgent::discoverRoute(int dest) {

// Implement route discovery using associativity metrics

}

// Forward packet to the selected next hop

void ABRAgent::forwardPacket(Packet* p) {

hdr_ip* iph = hdr_ip::access(p);

int nextHop = routingTable_[iph->dst()];

// Code to forward the packet to the next hop

}

// Update associativity for a node

void ABRAgent::updateAssociativity(int nodeId) {

// Increase associativity count for the node

associativityTable_[nodeId]++;

}

// Handle link breaks and rediscover routes

void ABRAgent::handleLinkBreak() {

// Implement logic for handling link breaks

}

  1. Integrate the ABR Agent into NS2
  1. Modify the Makefile: Append the new ABRAgent class to the NS2 Makefile so that it obtains compiled with the rest of the simulator.
  2. Recompile NS2:

make clean

make

Step 4: Create a Tcl Script to Simulate ABR

When the ABR protocol is executed and compiled, create a Tcl script to mimic a network using ABR.

Example Tcl Script:

# Create a simulator object

set ns [new Simulator]

# Define the topology

set val(chan)   Channel/WirelessChannel

set val(prop)   Propagation/TwoRayGround

set val(netif)  Phy/WirelessPhy

set val(mac)    Mac/802_11

set val(ifq)    Queue/DropTail/PriQueue

set val(ll)     LL

set val(ant)    Antenna/OmniAntenna

set val(ifqlen) 50

set val(nn)     10

set val(x)      1000

set val(y)      1000

set val(stop)   100.0

set val(rp)     ABR   ;# Associative-Based Routing protocol

# Initialize the topology object

set topo [new Topography]

$topo load_flatgrid $val(x) $val(y)

# Create the God object

create-god $val(nn)

# Configure the nodes

$ns node-config -adhocRouting $val(rp) \

-llType $val(ll) \

-macType $val(mac) \

-ifqType $val(ifq) \

-ifqLen $val(ifqlen) \

-antType $val(ant) \

-propType $val(prop) \

-phyType $val(netif) \

-channelType $val(chan) \

-topoInstance $topo \

-agentTrace ON \

-routerTrace ON \

-macTrace ON \

-movementTrace ON

# Create nodes

for {set i 0} {$i < $val(nn)} {incr i} {

set node_($i) [$ns node]

}

# Define node positions and movement model

$node_(0) set X_ 100.0; $node_(0) set Y_ 200.0

$node_(1) set X_ 200.0; $node_(1) set Y_ 300.0

$node_(2) set X_ 300.0; $node_(2) set Y_ 400.0

$node_(3) set X_ 400.0; $node_(3) set Y_ 500.0

$node_(4) set X_ 500.0; $node_(4) set Y_ 600.0

# Set up traffic sources

set udp [new Agent/UDP]

$ns attach-agent $node_(0) $udp

set null [new Agent/Null]

$ns attach-agent $node_(4) $null

$ns connect $udp $null

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set packetSize_ 512

$cbr set interval_ 0.1

$cbr start

# Simulation end

$ns at $val(stop) “stop”

$ns at $val(stop) “$ns nam-end-wireless $val(stop)”

$ns at $val(stop) “exit 0”

proc stop {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

}

# Run the simulation

$ns run

Step 5: Run the Simulation

  1. We can save the Tcl script like abr_example.tcl.
  2. Open a terminal and navigate to the directory in which we saved the Tcl script.
  3. Run the simulation using the below command:

ns abr_example.tcl

Step 6: Analyse the Results

  • We can use the trace files and the network animator (NAM) to estimate the performance of the ABR protocol, concentrating on metrics like packet delivery ratio, end-to-end delay, and routing overhead.
  • Observe how efficiently ABR maintains stable routes and how it manages mobility in the network.

Additional Considerations

  • Associativity Metrics: Investigate with various methods of computing associativity and observe how it effects routing performance.
  • Performance Comparison: Compare ABR with other routing protocols such as AODV or DSR to assess its efficiency in maintaining stable routes.

In this manual, ABR protocol was addressed via an orderly process, implemented and assessed with the help of the simulation tool ns2. More informations will be offered regarding this protocol as per your needs.