To simulate IPv4 protocols in NS2 have includes configuring the simple network topology and setting up the nodes with proper IP addressing and routing protocols. NS2 supports numerous IPv4-related protocols, that encompass TCP/IP, UDP, and diverse routing protocols such as AODV, DSDV, and OSPF.
The following guide outlines how to simulate a project using IPv4 protocols in NS2.
Steps to Simulate IPv4 Protocol Projects Using NS2:
- Set up NS2
Make sure that we have NS2 installed on the computer. NS2 comes with built-in support for IPv4, so we don’t require installing additional packages for basic IPv4 functionalities.
- Overview of IPv4 Protocol in NS2
In NS2, nodes can be set up with IPv4, and we can replicate numerous transport protocols (TCP, UDP) and routing protocols over IPv4. We describe the network topology, configure links, assign IP addresses to nodes, and configure the chosen routing protocol.
- Write the TCL Script for IPv4 Simulation
Here’s an instance of how to simulate a simple IPv4 network using TCP/IP and UDP/IP communication among nodes:
Example TCL Script for IPv4 Simulation
# Create a new simulator object
set ns [new Simulator]
# Open files for tracing and NAM visualization
set tracefile [open ipv4.tr w]
$ns trace-all $tracefile
set namfile [open ipv4.nam w]
$ns namtrace-all $namfile
# Create network topology (define nodes)
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
# Define link bandwidth and delay
$ns duplex-link $n0 $n1 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 2Mb 10ms DropTail
# Set IP addresses (IPv4 simulation)
$n0 set addr_ 192.168.1.1
$n1 set addr_ 192.168.1.2
$n2 set addr_ 192.168.1.3
$n3 set addr_ 192.168.1.4
# Routing between nodes (can add custom routing protocols here)
$n0 add-route “192.168.1.0/24” $n1
$n1 add-route “192.168.1.0/24” $n2
$n2 add-route “192.168.1.0/24” $n3
# Create a TCP agent and attach it to n0
set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
# Create a TCP Sink agent and attach it to n3
set sink0 [new Agent/TCPSink]
$ns attach-agent $n3 $sink0
# Connect TCP and Sink agents
$ns connect $tcp0 $sink0
# Create a traffic generator (FTP) and attach to TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp0
$ns at 1.0 “$ftp start”
# Create a UDP agent and attach it to n0
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
# Create a Null agent to act as the sink for UDP traffic and attach it to n3
set null0 [new Agent/Null]
$ns attach-agent $n3 $null0
# Connect UDP and Null agents
$ns connect $udp0 $null0
# Create CBR traffic generator for UDP traffic
set cbr [new Application/Traffic/CBR]
$cbr set packetSize_ 500
$cbr set rate_ 1Mb
$cbr attach-agent $udp0
$ns at 2.0 “$cbr start”
# Set simulation end time
$ns at 10.0 “finish”
# Define the finish procedure
proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam ipv4.nam &
exit 0
}
# Run the simulation
$ns run
- Explanation of the Script
- Simulator Setup: A new simulator object is generated, and trace and NAM files are opened for logging and visualization.
- Node Creation: Four nodes (n0, n1, n2, and n3) are generated to signify a simple network topology.
- Link Configuration: Links among nodes are configured with bandwidth (2 Mb) and propagation delay (10 ms).
- IP Address Assignment: IPv4 addresses are allocated to each node in the form of 192.168.1.x. These are utilized to route packets among nodes.
- Routing: Simple routing rules are incorporate to make sure packets are forwarded appropriately among nodes. In more complex environment, routing protocols such as AODV or OSPF can be utilized.
- TCP/UDP Agents: A TCP agent is attached to n0, and a consistent sink is attached to n3. Similarly, UDP traffic is created among n0 and n3.
- Traffic Generators:
- FTP traffic is created over the TCP connection.
- Constant Bit Rate (CBR) traffic is created over UDP.
- Simulation Timing: Traffic generation initiate at 1.0 and 2.0 seconds for TCP and UDP respectively, and the simulation terminate at 10.0 seconds.
- Finish Procedure: The simulation complete, trace files are flushed, and NAM visualization is introduced automatically.
- Running the Simulation
Once we have written the TCL script (e.g., ipv4_simulation.tcl), execute it using the following command in the terminal:
ns ipv4_simulation.tcl
- Analyzing the Results
- NAM Visualization: Open the created .nam file in NAM to envision the packet flow among the nodes and how the IPv4 routing operates.
nam ipv4.nam
- Trace File Analysis: The .tr file logs all the events in the simulation. We can utilize AWK or Python scripts to measure this file for parameters like:
- Packet delivery ratio
- Throughput
- Latency
- Packet loss
- Optional Enhancements
We can expand this simple simulation by executing more advanced IPv4 scenarios, that contain:
- Dynamic Routing Protocols: Apply the protocols such as AODV, DSDV, or OSPF to replicate dynamic routing in the network.
- For example, to utilize AODV as the routing protocol, replace the add-route lines with:
$ns node-config -adhocRouting AODV
- Mobility: incorporate a mobility model (e.g., random waypoint) to replicate nodes moving in a wireless network:
set god_ [new God]
$ns at 0.0 “$node(0) setdest 100 100 10”
- IPv4 over Wireless Networks: Replicate an IPv4 network over wireless nodes by set up the wireless channel, MAC layer, and mobility model.
- Performance Analysis: Evaluate and relate the performance of TCP vs UDP over IPv4 based on throughput, packet loss, and delay.
- Advanced IPv4 Routing Protocol Simulation
We can replicate more complex IPv4 routing environment using routing protocols such as:
- OSPF (Open Shortest Path First)
- RIP (Routing Information Protocol)
- BGP (Border Gateway Protocol)
We identify implementations of these protocols or set up them in the C++ files if required. For example, for OSPF, we want to install additional modules or adjust the NS2 source code.
- Running Simulations for Performance Metrics
We can expand the above example to estimate specific parameters. For instance, if we need to measure packet delivery ratio (PDR) or throughput, utilize AWK or Python scripts to measure the .tr trace file.
Example AWK Script to Calculate Packet Delivery Ratio (PDR):
BEGIN { sent = 0; received = 0 }
{
if ($1 == “s” && $4 == “tcp”) { sent++ }
if ($1 == “r” && $4 == “tcp”) { received++ }
}
END {
print “Packet Delivery Ratio: ” (received / sent) * 100 “%”
}
To execute the AWK script:
awk -f pdr_calculate.awk ipv4.tr
We had clearly expounded the step-by-step procedures to simulate the IPv4 protocols in sequential order that were simulated by using the ns2 tool. More information will be shared regarding this process in the upcoming manual.
IPv4 Protocol projects are solely managed by phdprime.com, where our skilled team is committed to implementing them with the NS2 tool and sharing best project ideas and topics in this area. Please send us your complete details via email, and we will provide you with the best guidance. Our experts will ensure the simulation and project performance are executed to the highest standards.
