How to Implement Star Protocol in NS2

To implementing the Source Tree Adaptive Routing Protocol (STAR) in NS2 that has include to generating or simulating a routing protocol that consume the source trees to operate adaptive routing in a network, especially suitable for ad hoc networks. STAR is a proactive routing protocol that reduces overhead by sustaining partial routing information and constructing source trees for destinations as needed. Here, the given below is the procedure to implement the star protocol in ns2:

Step-by-Step Implementation:

Step 1: Understand the STAR Protocol

The STAR protocol uses a source tree mechanism in which the each node sustains a tree that denotes the paths to all destinations it knows about. Once a node needs to send data, it uses its source tree to regulate the route. STAR is intended to reduce the overhead interconnected with maintaining up-to-date routes in highly dynamic networks by avoiding frequent route updates.

Step 2: Set Up NS2

Make sure NS2 is installed and functioning properly on system. Meanwhile NS2 does not natively support STAR; we will need to execute the protocol from scratch.

Step 3: Implement the STAR Protocol in C++

  1. Create the STAR Protocol Agent Class

The given below is a simple structure for implementing the STAR protocol in NS2.

#include <agent.h>

#include <packet.h>

#include <trace.h>

#include <address.h>

#include <map>

#include <vector>

class STARAgent : public Agent {

public:

STARAgent();

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

void sendRouteUpdate();

void handleRouteUpdate(Packet* p);

void forwardPacket(Packet* p);

void buildSourceTree();

protected:

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

std::map<int, std::vector<int>> sourceTree_; // Destination -> Path (vector of node IDs)

};

// Constructor

STARAgent::STARAgent() : Agent(PT_UDP) {

// Initialize routing table and source tree

// Example: Prepopulate routing table for known nodes

routingTable_[1] = 2; // Route to node 1 via node 2

}

// Packet reception

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

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

if (iph->daddr() == addr()) {

// Packet is for this node; process it

} else if (iph->ttl() <= 0) {

// Drop packet if TTL has expired

drop(p);

} else {

// Forward the packet using the routing table

forwardPacket(p);

}

}

// Send a route update to neighbors

void STARAgent::sendRouteUpdate() {

Packet* p = allocpkt();

hdr_cmn* cmnh = hdr_cmn::access(p);

cmnh->ptype() = PT_ROUTE_UPDATE;

// Set source address and other routing update info

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

iph->saddr() = addr();

iph->daddr() = IP_BROADCAST; // Broadcast the route update

cmnh->size() = sizeof(hdr_cmn) + sizeof(hdr_ip);

// Send the route update to neighbors

send(p, 0);

}

// Handle incoming route updates

void STARAgent::handleRouteUpdate(Packet* p) {

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

int src = iph->saddr();

// Update the routing table and source tree based on the received update

buildSourceTree();

// Propagate the route update if necessary

sendRouteUpdate();

}

// Build the source tree for routing

void STARAgent::buildSourceTree() {

// Implement source tree construction based on the routing table

// The source tree will map destinations to paths (sequence of nodes)

}

// Forward a packet using the source tree

void STARAgent::forwardPacket(Packet* p) {

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

int dest = iph->daddr();

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

int nextHop = routingTable_[dest];

send(p, nextHop);

} else {

// Drop packet if no route is found

drop(p);

}

}

  1. Define Packet Types and Structures

STAR needs to describe the custom packet types for route updates and possibly other control messages:

#define PT_STAR_ROUTE_UPDATE 50

// Add this to the packet.h file in NS2’s source code

packet_t PT_STAR_ROUTE_UPDATE;

We will also need to adjust the ns-default.tcl to recognize these packet types.

  1. Integrate the Protocol into NS2
  1. Modify the Makefile: Add the new STARAgent class to the NS2 Makefile so that it gets compiled with the rest of the simulator.
  2. Recompile NS2:

make clean

make

Step 4: Create a Tcl Script to Simulate the STAR Protocol

Once STAR is executed and compiled, generate a Tcl script to emulate a network using this protocol.

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(ifqlen) 50

set val(stop)   100.0

# Initialize the topology object

set topo [new Topography]

$topo load_flatgrid 1000 1000

# Create nodes

for {set i 0} {$i < 10} {incr i} {

set node_($i) [$ns node]

}

# Define node positions

$node_(0) set X_ 100.0

$node_(0) set Y_ 200.0

$node_(1) set X_ 300.0

$node_(1) set Y_ 400.0

# … Define the rest of the node positions

# Attach STAR agents to nodes

for {set i 0} {$i < 10} {incr i} {

set star_($i) [new Agent/STARAgent]

$ns attach-agent $node_($i) $star_($i)

}

# Set up traffic sources and sinks

set udp [new Agent/UDP]

set null [new Agent/Null]

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

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

$ns connect $udp $null

# Start sending data from node 0 to node 9

$ns at 0.0 “$udp start”

# Simulation end

$ns at $val(stop) “stop”

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

proc stop {} {

global ns

$ns flush-trace

exit 0

}

# Run the simulation

$ns run

Step 5: Run the Simulation

  1. Save the Tcl script (star_protocol_simulation.tcl).
  2. Open a terminal and navigate to the directory in which we saved the Tcl script.
  3. Track the simulation using the following command:

ns star_protocol_simulation.tcl

Step 6: Analyze the Results

  • Use trace files and the network animator (NAM) to evaluate the performance of the STAR protocol concentrates on parameters like packet delivery ratio, routing efficiency, and latency.
  • Test on how efficiently the protocol constructs and maintains the source tree for routing.

Additional Considerations

  • Scalability: Evaluate STAR in larger networks with more nodes to implements its scalability.
  • Optimization: Reflect the execution optimizations to minimize the control overhead and enhance the effectiveness of source tree management.
  • Mobility: Replicate the mobility to monitor on how STAR adjusts to dynamic network conditions.

From the demonstration, we understood the clear explanation about how to simulate the scenarios, configuration setup and how to analyse the outcomes for the STAR protocol that were executed using ns2 tool. Additional specific details regarding the STAR protocol will be provided. For the successful implementation of the Star Protocol in NS2, look no further than ns2project.com. Our team is dedicated to assisting you with proactive routing protocols. Simply share your project details with us, and we will provide you with comprehensive guidance. Additionally, we specialize in adaptive routing within networks for your projects. Trust us to help you achieve your goals efficiently.