Study of TCP/UDP Performance Using NS-2
Aim: To study and compare the performance of TCP and UDP
using the NS-2 simulation tool. (Packet transmission, Packet loss, Throughput and
Packet Delivery Ratio (PDR))
Simulation
setup
|
Parameter |
TCP |
UDP |
|
Number of
application packets |
1000 |
1000 |
|
Packet size |
1000 bytes |
1000 bytes |
|
Total
application data |
1 MB |
1 MB |
|
Bottleneck
bandwidth |
1 Mbps |
1 Mbps |
Steps to execute
1.
Install NS-2 in Google Colab
a.
Open Google Colab and create a new notebook
b.
Check the Linux environment
o
!uname -a
c.
Update the package list
o
!apt-get update -qq
d.
Install NS-2
o
!apt-get install -y ns2
e.
Check the NS-2 installation and verify
o
!which ns
2.
TCP UDP Performance analysis.
a.
Create the TCL file
b.
Run the TCL program
c.
Check the generated files
d.
Analyse the tracefile and plot the result
TCP UDP Performance analysis
Create the tcl
file
%%writefile
tcp_udp.tcl
# Create
simulator
set ns [new
Simulator]
# Create trace
file
set tracefile
[open tcp_udp.tr w]
$ns trace-all
$tracefile
# Create nodes
set n0 [$ns node]
;# TCP source
set n1 [$ns node]
;# UDP source
set n2 [$ns node]
;# Router
set n3 [$ns node]
;# Router
set n4 [$ns node]
;# Destination
# Create links
$ns duplex-link
$n0 $n2 10Mb 10ms DropTail
$ns duplex-link
$n1 $n2 10Mb 10ms DropTail
# Bottleneck link
$ns duplex-link
$n2 $n3 1Mb 20ms DropTail
$ns duplex-link
$n3 $n4 10Mb 10ms DropTail
# Queue limit
$ns queue-limit
$n2 $n3 10
# TCP CONNECTION
# TCP Reno agent
set tcp [new
Agent/TCP/Reno]
$tcp set
packetSize_ 1000
# Attach TCP to
n0
$ns attach-agent
$n0 $tcp
# TCP receiver
set tcpsink [new
Agent/TCPSink]
$ns attach-agent
$n4 $tcpsink
$ns connect $tcp
$tcpsink
# TCP traffic
set tcp_app [new
Application/Traffic/CBR]
$tcp_app set
packetSize_ 1000
$tcp_app set
interval_ 0.01
$tcp_app set
random_ false
$tcp_app
attach-agent $tcp
# UDP CONNECTION
# UDP agent
set udp [new
Agent/UDP]
$udp set
packetSize_ 1000
$ns attach-agent
$n1 $udp
# UDP receiver
set null [new
Agent/Null]
$ns attach-agent
$n4 $null
$ns connect $udp
$null
# UDP traffic
set udp_app [new
Application/Traffic/CBR]
$udp_app set
packetSize_ 1000
$udp_app set
interval_ 0.01
$udp_app set
random_ false
$udp_app
attach-agent $udp
# START
TRANSMISSION
$ns at 0.5
"$tcp_app start"
$ns at 0.5
"$udp_app start"
# STOP
TRANSMISSION
$ns at 10.5
"$tcp_app stop"
$ns at 10.5
"$udp_app stop"
# END SIMULATION
$ns at 11.0
"finish"
# Finish
procedure
proc finish {} {
global ns tracefile
$ns
flush-trace
close $tracefile
exit 0
}
# Run simulation
$ns run
Run the TCL
program
!ns tcp_udp.tcl
Check the
generated files
!ls -lh tcp_udp*
Analyze the trace
file and plot the result
# TCP vs UDP
Performance Analysis
TCP_GENERATED = 1000
UDP_GENERATED = 1000
tcp_received = 0
udp_received = 0
tcp_bytes = 0
udp_bytes = 0
tcp_dropped = 0
udp_dropped = 0
with open("tcp_udp.tr",
"r") as f:
for
line in f:
fields = line.split()
if len(fields) < 6:
continue
event = fields[0]
from_node = fields[2]
to_node = fields[3]
packet_type = fields[4]
try:
packet_size = int(fields[5])
except:
continue
# TCP received at destination n4
if (event == "r" and
to_node == "4" and
packet_type == "tcp"):
tcp_received += 1
tcp_bytes += packet_size
# UDP received at destination n4
if (event == "r" and
to_node == "4" and
packet_type == "cbr"):
udp_received += 1
udp_bytes += packet_size
# Dropped packets
if event == "d":
if packet_type == "tcp":
tcp_dropped += 1
elif packet_type == "cbr":
udp_dropped += 1
# Packet Loss
tcp_loss =
TCP_GENERATED - tcp_received
udp_loss =
UDP_GENERATED - udp_received
# PDR
tcp_pdr =
(tcp_received / TCP_GENERATED) * 100
udp_pdr =
(udp_received / UDP_GENERATED) * 100
# Throughput
duration = 10.0
tcp_throughput =
(tcp_bytes * 8/(duration * 1000000))
udp_throughput =
(udp_bytes * 8/(duration * 1000000))
# Display Results
print("
TCP vs UDP PERFORMANCE")
print(f"{'Metric':<25}{'TCP':<15}{'UDP':<15}")
print(f"{'Packets
Generated':<25}"
f"{TCP_GENERATED:<15}"
f"{UDP_GENERATED:<15}")
print(f"{'Packets
Received':<25}"
f"{tcp_received:<15}"
f"{udp_received:<15}")
print(f"{'Packet
Loss':<25}"
f"{tcp_loss:<15}"
f"{udp_loss:<15}")
print(f"{'Packets
Dropped':<25}"
f"{tcp_dropped:<15}"
f"{udp_dropped:<15}")
print(f"{'PDR
(%)':<25}"
f"{tcp_pdr:<15.2f}"
f"{udp_pdr:<15.2f}")
print(f"{'Throughput
(Mbps)':<25}"
f"{tcp_throughput:<15.4f}"
f"{udp_throughput:<15.4f}")
Packet Loss
import
matplotlib.pyplot as plt
protocols = ["TCP",
"UDP"]
loss = [tcp_loss,
udp_loss]
plt.figure(figsize=(7,5))
plt.bar(protocols,
loss)
plt.xlabel("Protocol")
plt.ylabel("Number
of Packets")
plt.title("TCP
vs UDP Packet Loss")
plt.show()
Throughput
throughput =
[tcp_throughput, udp_throughput]
plt.figure(figsize=(7,5))
plt.bar(protocols,
throughput)
plt.xlabel("Protocol")
plt.ylabel("Throughput
(Mbps)")
plt.title("TCP
vs UDP Throughput")
plt.show()
Packet
Delivery Ratio
pdr = [tcp_pdr,
udp_pdr]
plt.figure(figsize=(7,5))
plt.bar(protocols,
pdr)
plt.xlabel("Protocol")
plt.ylabel("Packet
Delivery Ratio (%)")
plt.title("TCP
vs UDP Packet Delivery Ratio")
plt.ylim(0, 100)
plt.show()
Result: The performance of TCP and UDP was successfully studied
using NS-2 simulation. TCP and UDP traffic were generated through a common
bottleneck link, and their performance was analyzed using packet delivery,
packet loss and throughput measurements.
