How to Implement Token Ring Topology in NS2

To implement Token Ring Topology in ns2 has series of steps to follow and basically it is a network topology in which the nodes are associated in a circular manner, and a special token circulates nearby the network. Only the node that holds the token can transfers the data. This prevents collisions in the network, as only one node can deliver data at a time. Once the transmission is completed then the token is passed to the next node.

ns2project.com, provide expert guidance on implementing Token Ring Topology in NS2 tool. share your project details with us, and we will assist you in conducting a thorough comparison analysis.

In Network Simulator 2 (NS2), there is no direct support for the Token Ring protocol; however we can mimic a Token Ring topology by generating a ring topology and using a token-based scheduling mechanism. We can estimated the characteristics of a Token Ring by making sure that only one node can deliver information at a time and the token is passed to the next node.

Here, is an implementation protocol to execute the token ring topology in ns2:

Steps to Implement Token Ring Topology in NS2:

  1. Set Up the Ring Topology:
    • Generate nodes and organize them in a ring (each node is connected to the next, and the last node connects to the first).
  2. Simulate the Token Passing Mechanism:
    • Execute a simple token-passing mechanism by permits only one node to transmit at a time. After the current node concludes transmission, the next node is permit to transmit.
  3. Simulate Traffic Flow:
    • Make traffic among nodes in the network according to the token-passing mechanism.

Example of Token Ring Topology Implementation in NS2:

The given below is an example NS2 script that mimic a Token Ring Topology with 4 nodes, in which the token is passed from one node to the next that enables only one node to transmit at a time.

# Create a new simulator

set ns [new Simulator]

# Open trace files for output

set tracefile [open out.tr w]

$ns trace-all $tracefile

# Define nodes in the ring (4 nodes for simplicity)

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

# Create duplex links to form a ring (last node connects back to the first)

$ns duplex-link $n0 $n1 10Mb 5ms DropTail

$ns duplex-link $n1 $n2 10Mb 5ms DropTail

$ns duplex-link $n2 $n3 10Mb 5ms DropTail

$ns duplex-link $n3 $n0 10Mb 5ms DropTail  ;# Complete the ring

# Only one node can transmit at a time (simulate token passing)

# Traffic from n0 to n2 (start token at node n0)

set tcp0 [new Agent/TCP]

set sink0 [new Agent/TCPSink]

$ns attach-agent $n0 $tcp0

$ns attach-agent $n2 $sink0

$ns connect $tcp0 $sink0

# Start traffic from n0 to n2 at 1 second (token at n0)

set ftp0 [new Application/FTP]

$ftp0 attach-agent $tcp0

$ns at 1.0 “$ftp0 start”

$ns at 2.5 “$ftp0 stop”  ;# Stop transmission from n0 at 2.5 seconds

# Traffic from n1 to n3 (token passes to node n1)

set tcp1 [new Agent/TCP]

set sink1 [new Agent/TCPSink]

$ns attach-agent $n1 $tcp1

$ns attach-agent $n3 $sink1

$ns connect $tcp1 $sink1

# Start traffic from n1 to n3 at 3 seconds (token at n1)

set ftp1 [new Application/FTP]

$ftp1 attach-agent $tcp1

$ns at 3.0 “$ftp1 start”

$ns at 4.5 “$ftp1 stop”  ;# Stop transmission from n1 at 4.5 seconds

# Traffic from n2 to n0 (token passes to node n2)

set tcp2 [new Agent/TCP]

set sink2 [new Agent/TCPSink]

$ns attach-agent $n2 $tcp2

$ns attach-agent $n0 $sink2

$ns connect $tcp2 $sink2

# Start traffic from n2 to n0 at 5 seconds (token at n2)

set ftp2 [new Application/FTP]

$ftp2 attach-agent $tcp2

$ns at 5.0 “$ftp2 start”

$ns at 6.5 “$ftp2 stop”  ;# Stop transmission from n2 at 6.5 seconds

# Traffic from n3 to n1 (token passes to node n3)

set tcp3 [new Agent/TCP]

set sink3 [new Agent/TCPSink]

$ns attach-agent $n3 $tcp3

$ns attach-agent $n1 $sink3

$ns connect $tcp3 $sink3

# Start traffic from n3 to n1 at 7 seconds (token at n3)

set ftp3 [new Application/FTP]

$ftp3 attach-agent $tcp3

$ns at 7.0 “$ftp3 start”

$ns at 8.5 “$ftp3 stop”  ;# Stop transmission from n3 at 8.5 seconds

# End the simulation after 10 seconds

$ns at 10.0 “finish”

proc finish {} {

global ns tracefile

$ns flush-trace

close $tracefile

exit 0

}

# Run the simulation

$ns run

Explanation of the Script:

  1. Nodes:
    • n0, n1, n2, n3 are the nodes in the token ring topology. These nodes are associated in a circular manner (ring).
  2. Links:
    • Duplex links are generated to interconnect the nodes in a ring. Each node is associated to its neighbour, and the last node associates back to the first (n3 to n0).
  3. Token Passing Mechanism:
    • The token-passing mechanism is regulated by controlling the traffic start and stop times for each node. For instance, n0 transmits traffic to n2 among 1 and 2.5 seconds, and once its transmission is finished, the token is passed to n1, that initiates to transmitting at 3 seconds.
    • The token make sure that only one node can transmit at a time, mimic the token ring protocol.
  4. Traffic Simulation:
    • TCP agents are used to mimic interaction among nodes.
    • FTP (File Transfer Protocol) is used to create traffic among the nodes. For instance, n0 sends data to n2, n1 sends data to n3, and so on.
    • Each node is permitted to transmit only when it holds the token, and it sends for a limited time before passing the token to the next node.
  5. Simulation Duration:
    • The simulation executes for 10 seconds, during that all nodes transmit data according to the token-passing mechanism.

Post-Simulation Analysis:

  1. Trace File Analysis:
    • The trace file (out.tr) will cover information about packet transmission, delivery, latency, and throughput. We need to evaluate the trace file to see how information is transferred and how the token is passed among the nodes.
  2. NAM Visualization:
    • We need to visualize the token ring topology and the flow of traffic using NAM (Network Animator). The ring structure and the sequential flow of traffic as the token is passed among nodes will be visible.
  3. Performance Metrics:
    • Evaluate network parameters like delay, throughput, and packet loss to measure the performance of the token ring network.

Enhancing the Simulation:

  1. Adding More Nodes:
    • Additionally more nodes to replicate a larger token ring topology.
  2. Dynamic Token Passing:
    • Execute a more dynamic token-passing mechanism in which token requests and grants are mimicked in real-time.
  3. Simulating Link or Node Failures:
    • Mimic node or link failures to monitor on how the token ring topology manages failures.
  4. Changing Traffic Types:
    • Interchange TCP with UDP or mimic numerous kinds of traffic like CBR to measure on how the token ring network manages numerous traffic patterns.
  5. Varying Link Parameters:
    • Validate with diverse link parameters like bandwidth, delay, and queue types like DropTail, RED to evaluate on how the network performance vary in diverse conditions.

As we conversed earlier about how the Token Ring Topology will evaluate the outcomes in ns2 tool and we help to deliver additional material about how the Token Ring Topology will adapt in diverse surroundings.