Engineering Clinic

Wired Networks in NS2 - NS2 Tutorial 5

2021-10-26T14:44:00.007+05:30

Wired Networks

In this post:

· Introduction to Wired networks

· Tcl scripts for various wired networks

Wired networks are easier to setup as they need a physical link between the nodes and hence they form a network by having a duplex or simplex link. Also we have seen an example of a two node network in Chapter 1 that informs how to connect two nodes in a network with a duplex link.

This chapter tells about the various wired network supported in ns2 and examples to showcase these networks.

This wired example sets the shape for the nodes and also sets labels for the node. Each node can be differentiated using labels like client, server. Etc. There are 3 shapes supported by ns2, they are hexagon, square and circle. Once the shape is fixed, the shapes can't be changed during the simulation.

$node shape hexagon

Also the nodes can be colored using the coloring values, there are so many colors supported by ns and some of them are blue, red, green, orange, magenta, etc.

$node color name

the following examples depicts three nodes that are either colored,shaped and labelled. The following network does not have any traffic generation or simulation. Its just informs the attributes of the node.

Sometimes the node can be marked with a color and shape with a name. The syntax is

$node add-mark name color shape

Listing 4.1 – To set the attributes of the node like shape, color, label, marking.

#Create global variables

set ns [new Simulator]

#setting nam trace

set namf [open wired1.nam w]

$ns namtrace-all $namf

#open the trace file

set tracef [open wired1.tr w]

$ns trace-all $tracef

set proto rlm

#setting the color values

$ns color 1 blue

$ns color 2 yellow

$ns color 3 red

#---------- creating client- router- end server node----------------#

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

#establish the link between the nodes

$ns duplex-link $n0 $n1 2Mb 100ms DropTail

$ns duplex-link $n1 $n2 200Kb 100ms DropTail

#Label the nodes

$ns at 0.0 "$n0 label Client1"

$ns at 0.0 "$n1 label Server"

$ns at 0.0 "$n2 label Client2"

#setting the color for nodes

$n0 color blue

$n1 color red

$n2 add-mark pradeep green square

#Shaping the nodes for differentiation

$n1 shape hexagon

$n2 shape square

#finish procedure

proc finish {} {

global ns tracef namf

$ns flush-trace

close $tracef

close $namf

puts "Opening nam..."

exec nam wired1.nam &

exit 0

}

#Calling finish procedure

$ns at 2.0 "finish"

$ns run

The above listing just shows two clients and a server and there was no traffic and it is just to create a topology and Fig 4.1 shows this

A simple Wired network with three nodes

Tcp Source and the Sink Agent

This example shows the simple Tcp with FTP Traffic. Since in wired networks, Tcp is a connection oriented transport protocol which needs an acknowledgment for every packet it sents. The following network shows that. There are 4 nodes, and two nodes are exchanging packets between them and an intermediate node is forwarding the packet to the destination node. The performance characteristics of this network is analysed in the next section.

The C++ source code relevant to Tcp is available in the ~ns-2.35/tcp/tcp.cc. Also it involves various parameters during the simulation like congestion window, duplicate acknowledgement, and sequence no, etc.

Also this network used a FTP (File Transfer Protocol) for the traffic.

Listing 4.2 – Tcl Script to show the TCP with FTP Traffic

#Set the simulator

set ns [new Simulator]

#Opening the network animation

set namf [open wired2.nam w]

$ns namtrace-all $namf

#open the file for tracing

set tracef [open wired2.tr w]

$ns trace-all $tracef

#creation of wired nodes

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

#establish the links between the nodes with bandwidth and delay

$ns duplex-link $n0 $n1 2MB 1ms DropTail

$ns duplex-link $n1 $n2 2.5MB 1ms RED

$ns duplex-link $n2 $n3 2MB 1.5ms DropTail

$ns duplex-link $n3 $n1 12MB 10ms DropTail

#creating the Tcp source and sink agents

set tcp [new Agent/TCP]

set sink [new Agent/TCPSink]

#attach the agents to the corresponding nodes

$ns attach-agent $n0 $tcp

$ns attach-agent $n2 $sink

#create the FTP Traffic

set ftp [new Application/FTP]

$ftp attach-agent $tcp

$ns connect $tcp $sink

#start the traffic

$ns at 1.0 "$ftp start"

#end the simulation

$ns at 3.0 "finish"

proc finish {} {

global ns namf tracef

$ns flush-trace

close $namf

close $tracef

exec nam wired2.nam &

exit 0

}

$ns run

A Wired network with Four nodes with FTP Traffic

The Listing 4.2 shows a simple wired network with four nodes that just involves in a FTP Traffic. The Fig 4.2 shows this.

Wired network with various traffic

NS supports various traffic that may be employed in Tcl scripts to test. Some examples are

• CBR Traffic

• FTP Traffic

• Exponential Traffic

• Telnet Traffic

• SMTP

These traffic can be simulated in TCP or UDP Agents.

The following Listing depicts these traffics. For example, SMTP (Simple Mail Transfer protocol) traffic is more like exponential traffic and this can be simulated using Application/Traffic/Exponential.

Listing 4.3 – Tcl Script to show various traffics in the network

There are totally 10 wired nodes that shares duplex links between them. Four of the links are enabled with ftp, cbr,smtp and telnet traffic. The following listing shows the simulation with the snapshot of the animation.

#Set the global variable

set ns [new Simulator]

#create the file for animation

set namf [open wired3.nam w]

$ns namtrace-all $namf

#create the file for tracing

set tracef [open wired3.tr w]

$ns trace-all $tracef

#creation of nodes using for loop

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

set node($i) [$ns node]

}

#establishing the duplex links between the nodes

$ns duplex-link $node(0) $node(1) 2mb 1ms DropTail

$ns duplex-link $node(2) $node(3) 1mb 10ms DropTail

$ns duplex-link $node(1) $node(6) 3mb 10ms DropTail

$ns duplex-link $node(4) $node(3) 2mb 50ms DropTail

$ns duplex-link $node(8) $node(1) 3mb 25ms DropTail

$ns duplex-link $node(6) $node(4) 1mb 30ms DropTail

$ns duplex-link $node(7) $node(5) 2mb 15ms DropTail

$ns duplex-link $node(8) $node(4) 20mb 4ms DropTail

$ns duplex-link $node(2) $node(5) 2mb 100ms DropTail

$ns duplex-link $node(0) $node(9) 12mb 10ms DropTail

$ns duplex-link $node(0) $node(3) 20mb 14ms DropTail

$ns duplex-link $node(9) $node(7) 20mb 4ms DropTail

#define the procedure for smtp traffic with two nodes as parameters

proc traffic_smtp {n0 n1} {

global ns

set smtpsource [new Agent/UDP]

set smtpsink [new Agent/UDP]

$ns attach-agent $n0 $smtpsource

$ns attach-agent $n1 $smtpsink

$ns connect $smtpsource $smtpsink

set smtp_traffic [new Application/Traffic/Exponential]

$smtp_traffic attach-agent $smtpsource

$smtp_traffic set burst_time_ 50ms

$smtp_traffic set idle_time_ 50ms

$smtp_traffic set rate_ 100k

$smtp_traffic set packetSize_ 100

$ns at 0.1 "$smtp_traffic start"

$ns at 1.0 "$smtp_traffic stop"

}

#call the procedure

traffic_smtp $node(0) $node(1)

#define the procedure for CBR traffic with two nodes as parameters

proc traffic_cbr {n2 n3} {

global ns

set cbrsource [new Agent/UDP]

set cbrsink [new Agent/Null]

$ns attach-agent $n2 $cbrsource

$ns attach-agent $n3 $cbrsink

$ns connect $cbrsource $cbrsink

set cbr_traffic [new Application/Traffic/CBR]

$cbr_traffic attach-agent $cbrsource

$cbr_traffic set interval_ 50

$cbr_traffic set packetSize_ 50

$ns at 1.0 "$cbr_traffic start"

$ns at 2.0 "$cbr_traffic stop"

}

#call the CBR Traffic procedure

traffic_cbr $node(2) $node(3)

#define the procedure for FTP traffic with two nodes as parameters

proc traffic_ftp {n1 n6} {

global ns

set ftpsource [new Agent/TCP]

set ftpsink [new Agent/TCPSink]

$ns attach-agent $n1 $ftpsource

$ns attach-agent $n6 $ftpsink

$ns connect $ftpsource $ftpsink

set ftp_traffic [new Application/FTP]

$ftp_traffic attach-agent $ftpsource

$ftp_traffic set interval_ 50

$ftp_traffic set packetSize_ 50

$ns at 2.0 "$ftp_traffic start"

$ns at 3.0 "$ftp_traffic stop"

}

#call the ftp traffic procedure

traffic_ftp $node(1) $node(6)

#define the procedure for Telnet traffic with two nodes as parameters

proc traffic_telnet {n8 n1} {

global ns

set telnetsource [new Agent/TCP]

set telnetsink [new Agent/TCPSink]

$ns attach-agent $n8 $telnetsource

$ns attach-agent $n1 $telnetsink

$ns connect $telnetsource $telnetsink

set telnet_traffic [new Application/Telnet]

$telnet_traffic attach-agent $telnetsource

$telnet_traffic set interval_ 0.005

$ns at 3.0 "$telnet_traffic start"

$ns at 4.0 "$telnet_traffic stop"

}

#call the telnet traffic

traffic_telnet $node(8) $node(1)

#Trace annotation during the animation. Theese string will be displayed in the NAM window

$ns at 0.1 "$ns trace-annotate \"Time: 0.1 SMTP Traffic from Node 0 to Node 1 ..\""

$ns at 1.0 "$ns trace-annotate \"Time: 1.0 CBR Traffic from Node 2 to Node 3 ..\""

$ns at 2.0 "$ns trace-annotate \"Time: 2.0 FTP Traffic from Node 1 to Node 6..\""

$ns at 3.0 "$ns trace-annotate \"Time: 3.0 Telnet Traffic from Node 8 to Node 1..\""

#call the procedure finish

$ns at 5.0 "finish"

#creation of finish procedure

proc finish {} {

global ns namf tracef

$ns flush-trace

close $namf

close $tracef

}

$ns run

Wired network with CBR, SMTP, Telnet and FTP Traffic

The Listing 4.3 shows some new things in ns, they are

• Different applications like

◦ FTP Traffic - Application/FTP

◦ CBR Traffic - Application/Traffic/CBR

◦ SMTP Traffic - Application/Traffic/Exponential

◦ Telnet Traffic - Application/Telnet

• This script uses the trace-annotate command that uses to display string during the animation as shown in Fig 4.3

• This script also uses procedure with parameters. Four procedures were used with two parameters as the node names.

• Also node creation is done using For loop and the nodes are named as array values. Ex. node0, node1, etc.

Printing the properties of Tcp Reno Agent

The following listing prints the congestion window of the TcpReno agent and plots it using xgraph. Xgraph is third party software that comes with the ns allinone package.

Congestion window size is a major factor in predicting the performance of a TCP Network. NS2 handles the Congestion window using a variable cwnd_ and it can be printed to a graph and as well printed as values at various intervals of time.

The following Tcl script will let you understand the working of the network (TCP Reno Protocol) and also helps you in plotting the characteristics of Congestion window value.

Listing 4.4 – Tcl Script to print the Congestion Window of TcpReno Agent.

#create simulator

set ns [new Simulator]

#to create nodes

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

set n5 [$ns node]

# to create the link between the nodes with bandwidth, delay and queue

$ns duplex-link $n0 $n2 2Mb 10ms DropTail

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

$ns duplex-link $n2 $n3 0.3Mb 200ms DropTail

$ns duplex-link $n3 $n4 0.5Mb 40ms DropTail

$ns duplex-link $n3 $n5 0.5Mb 30ms DropTail

# Sending node is 0 with agent as Reno Agent

set tcp1 [new Agent/TCP/Reno]

$ns attach-agent $n0 $tcp1

# receiving (sink) node is n4

set sink1 [new Agent/TCPSink]

$ns attach-agent $n4 $sink1

# establish the traffic between the source and sink

$ns connect $tcp1 $sink1

# Setup a FTP traffic generator on "tcp1″

set ftp1 [new Application/FTP]

$ftp1 attach-agent $tcp1

$ftp1 set type_ FTP

# start/stop the traffic

$ns at 0.1 "$ftp1 start"

$ns at 40.0 "$ftp1 stop"

# Set simulation end time

$ns at 50.0 "finish"

# procedure to plot the congestion window

proc plotWindow {tcpSource outfile} {

global ns

set now [$ns now]

set cwnd [$tcpSource set cwnd_]

# the data is recorded in a file called congestion.xg (this can be plotted # using xgraph or gnuplot. this example uses xgraph to plot the cwnd_

puts $outfile "$now $cwnd"

$ns at [expr $now+0.1] "plotWindow $tcpSource $outfile"

}

set outfile [open "congestion.xg" w]

$ns at 0.0 "plotWindow $tcp1 $outfile"

proc finish {} {

exec xgraph congestion.xg -geometry 300×300 &

exit 0

}

# Run simulation

$ns run

Congestion window of a Tcp Reno Agent

The listing 4.4 has the facility of printing the congestion window in a graph and Fig 4.4 shows this. As in Fig 4.4, the congestion window is initially at a value of 1 and increases periodically over a period of time.

Listing 4.5 – Wired network

# enable the multicast routing protocol in ns2

set ns [ new Simulator -multicast on]

# Creating network animation

set namf [open wired3.nam w]

$ns namtrace-all $namf

#Open the trace file

set tracef [open wired3.tr w]

$ns trace-all $tracef

#define the multicast routing protocol

set proto rlm

#------------COLOR DESCRIPTION---------------#

$ns color 1 dodgerblue

$ns color 2 red

$ns color 3 cyan

$ns color 4 green

$ns color 5 yellow

$ns color 6 black

$ns color 7 magenta

$ns color 8 gold

$ns color 9 red

# --------- CREATING SENDER - RECEIVER - ROUTER NODES-----------#

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

set m1 [$ns node]

set m2 [$ns node]

set m3 [$ns node]

set m4 [$ns node]

set Router1 [$ns node]

set Router2 [$ns node]

set Router3 [$ns node]

$ns duplex-link $n1 $Router1 1Mb 10ms DropTail

$ns duplex-link $n2 $Router1 500Kb 10ms DropTail

$ns duplex-link $n3 $Router1 750Kb 10ms DropTail

$ns duplex-link $n4 $Router2 1Mb 10ms DropTail

$ns duplex-link $m1 $Router1 1Mb 10ms DropTail

$ns duplex-link $m2 $Router1 1Mb 10ms DropTail

$ns duplex-link $m3 $Router1 1Mb 10ms DropTail

$ns duplex-link $m4 $Router3 1Mb 10ms DropTail

$ns duplex-link $Router2 $Router1 1Mb 10ms DropTail

$ns duplex-link $Router2 $Router3 1Mb 10ms DropTail

$ns duplex-link $Router1 $Router3 1Mb 10ms DropTail

# queue size, beyond this size, the packets will be dropped

$ns queue-limit $Router1 $Router2 20

$ns queue-limit $Router1 $Router3 20

$ns queue-limit $Router2 $Router1 20

$ns queue-limit $Router3 $Router1 25

# label the nodes as per their nature of work

$ns at 0.0 "$n1 label Client1"

$ns at 0.0 "$n2 label Client2"

$ns at 0.0 "$n3 label Client3"

$ns at 0.0 "$n4 label Client4"

$ns at 0.0 "$m1 label Client5"

$ns at 0.0 "$m2 label Client6"

$ns at 0.0 "$m3 label Client7"

$ns at 0.0 "$m4 label Client8"

$ns at 0.0 "$Router1 label Router1"

$ns at 0.0 "$Router2 label Router2"

$ns at 0.0 "$Router3 label Router3"

# defining the shapes for the nodes

$Router1 shape square

$Router2 shape square

$Router3 shape square

#setting the colors for the links

$ns duplex-link-op $Router1 $Router2 color cyan

$ns duplex-link-op $Router1 $Router3 color cyan

$ns duplex-link-op $Router2 $Router3 color cyan

# establishing the connection and the agents

#includes maximum congestion window, the packetSize and flow id

set tcp1 [$ns create-connection TCP $n1 TCPSink $m4 1]

$tcp1 set class_ 1

$tcp1 set maxcwnd_ 16

$tcp1 set packetsize_ 4000

$tcp1 set fid_ 1

set ftp1 [$tcp1 attach-app FTP]

$ftp1 set interval_ .005

$ns at 0.2 "$ftp1 start"

$ns at 4.0 "$ftp1 stop"

set tcp2 [$ns create-connection TCP $n2 TCPSink $m3 1]

$tcp2 set class_ 1

$tcp2 set maxcwnd_ 16

$tcp2 set packetsize_ 4000

$tcp2 set fid_ 2

set ftp2 [$tcp2 attach-app FTP]

$ftp2 set interval_ .005

$ns at 0.7 "$ftp2 start"

$ns at 4.0 "$ftp2 stop"

set tcp3 [$ns create-connection TCP $n3 TCPSink $m2 1]

$tcp3 set class_ 1

$tcp3 set maxcwnd_ 16

$tcp3 set packetsize_ 4000

$tcp3 set fid_ 3

set ftp3 [$tcp3 attach-app FTP]

$ftp3 set interval_ .005

$ns at 1.2 "$ftp3 start"

$ns at 4.0 "$ftp3 stop"

set tcp4 [$ns create-connection TCP $n4 TCPSink $m1 1]

$tcp4 set class_ 1

$tcp4 set maxcwnd_ 16

$tcp4 set packetsize_ 4000

$tcp4 set fid_ 4

set ftp4 [$tcp4 attach-app FTP]

$ftp1 set interval_ .005

$ns at 2.5 "$ftp4 start"

$ns at 4.0 "$ftp4 stop"

#define the finish procedure.

proc finish {} {

global ns namf tracef nf1

set NSHOME "/home/pradeepkumar/ns-allinone-2.35" ;#change path

set SETFID "$NSHOME/ns-2.35/bin/set_flow_id"

set RAW2XG_SCTP "$NSHOME/ns-2.35/bin/raw2xg-sctp"

$ns flush-trace

close $namf

exec perl $SETFID -s rands2.tr | \

perl $RAW2XG_SCTP -A -q > Rands2.rands

exec xgraph -bb -tk -nl -m -x time -y packets Rands2.rands &

$ns flush-trace

close $tracef

exit 0

}

#Calling finish procedure

$ns at 20.0 "finish"

$ns run

The Listing 4.5 uses the following:

· There are totally 11 nodes, 8 client nodes and 3 router nodes

· The links are colored

· All the nodes were labelled

· They use TCP Agents with FTP Flow with altered parameters like packetSize_, maximum congestion window specification, rate of transfer and flow id.

· The script uses the set_flow_id and raw2xg_sctp binaries provided by ns2 and it uses perl script to plot the characteristics of data sent, data drop etc.

The Network Animation window and the related the graphs are shown below.

The following figure shows the data sent, forwarded, received and dropped at all the links. The graph shows green color as dense dots as data generation is huge compared to the data forwarded, received or lost.

Network Animation

Packet data

TCL/TK Programming for NS2 - NS2 Tutorial 4

2021-10-26T14:35:00.003+05:30

Tcl/Tk Programming

In this post, you may learn

· To know the basics of Tcl/TK Programming

· To create a Tcl script

Tcl Programming

Over the span of 25 years a simple modular scripting language was developed and modified or improved by corporates, academia, open source community and web developers. The code developed and the binary source is free with no strings attached. This is one of the oldest scripting language still being used for testing the network equipment like routers, switches, etc. And used in electronic IC designs and used as a front end tool (testing tool) for Network Simulator 2 (NS2).

Tcl was created by John Ousterhout mainly for embedded system applications for its ability for rapid prototyping, scripted applications and also fir its small or bigger footprints.

3.1 Features of Tcl/Tk

Rapid Development: Tcl almost runs 5 to 10X faster than other scripting languages if it involves GUI, string handling or integration.

Graphical User Interface Using its Tk toolkit, Tcl provides facilities for creating GUIs that are incredibly simple yet remarkably powerful.

Cross Platform Tcl/Tk runs almost same on all operating systems like Windows, Macintosh, and Linux/Unix platform.

Continuous upgrades: Since 1990s Tcl and Tk have been under continuous and rapid upgrades which makes Tcl/Tk really a reliable and solid scripting language that can be relied upon.

Deployment Tcl can be deployed as a single application on a target machine very easily whereas other dynamic languages makes deployment harder.

Network-aware applications: Tcl has a wide number of event driven codes that are helpful in generating events for networked devices like routers, switches, routing extensions, etc.

Apart from these features, Tcl also has a vibrant Community that helps developers with provision of free extensions, plugins and updates. Also Tcl is easy to learn and all these come free. Tcl/Tk is completely free with even the binary source can also be modified or upgraded.

3.2 Tcl interpreter and Execution

Tcl scripts are usually having extension of .tcl and can be executed using tclsh or wish. In Linux/Unix families, following is the way to interpret the tcl scripts.

# tclsh filename.tcl

The command wish will be working for GUI and text mode. Sometimes tclsh can be coming along with version number for example tclsh86.exeand can be executed as follows

C:/> tclsh86 filename.tcl

C:/> source filename.tcl

Here is the screenshot of tclsh.

tclsh interpreter

Since this book is related to Network Simulator 2 (NS2), the commands and the syntax in this chapter will be related to NS2 and its simulation libraries. However for the understanding of new developers, bits and pieces of the tcl scripts are presented.

3.3 Getting Started

Let us go through some basic syntax of Tcl Programming. The following examples will give you a general introduction for Tcl Programming.

The syntax of Tcl is not similar to C or C++, rather it is simple and straightforward. This chapter will give you a glimpse of the Tcl syntax used in NS2

Example 1: “Hello World”

# This is an example to demonstrate the Hello World

puts “Hello World!”; #printing Hello World! to the screen

To run this file, tclsh ex1.tcl, if the operating system is windows then tclsh.exe ex1.tcl.

● puts is the command to print anything to screen

● if comments are to be placed at the end of the statement, then a trailing semi colon is a must, as shown in the example above.

● A comment always starts with a preceding # symbol.

3.3.1 Basic syntax

Tcl scripts are full of commands separated by newlines. A typical example of Command is given below.

 expr 3 + 10

This command computes the sum of 3 and 10 and returns the result, 13. You can try out this example using tclsh.

There are different words that are separated by space. There are four words in this example: expr, 3, +, and 10. The expr command is an arithmetic expression, computes the result of that expression, and returns the result as a string. Sometimes the same above command can also be represented as

expr 3+10

All commands returns results, even if a command has no results to display, it displays a empty string.

3.3.2 Assigning values to Variables

In Tcl, everything is represented as string, but internally it also represents integers, double, list or some other types. This enables faster interpretation.

For this, the assignment command is used in Tcl which is set. When the set command is dealing with two arguments as in:

set name TclTk

the (name) in the first command references which stores TclTk in the memory. Set command always returns the contents of the variable named in the first argument. So in this command, TclTk without quotes is being stored in the memory which is referenced by the (name) in the first command.

Set can also be invoked with only one argument. When called with just one argument, it will return the contents of that argument.

Here's a summary of the set command.

set variableName valueOfVariable

If valueOfVariableis specified, then the contents of the variable variableName are set equal to valueOfVariable. (Like the example we have seen above)

If variableName consists only of alphanumeric characters, and no parentheses, it is a scalar variable.

If variableName has the form variableName (index), it is a member of an associative array.

Example 2: “Variable and Values”

set Name “I am Tcl”

set A 10

puts $A

puts $Name

set label "The value in A is: "

puts "$label $A"

3.3.3 Command substitution

Command substitution is a important concept in Tcl where result of one command argument can be used for another command. Here is an example

set a 25

set b [expr $a*4]

When a [ appears in a command, Tcl treats everything between it and the matching ] as a nested Tcl command. Tcl evaluates the entire expr $a*4 as a single command and substitutes as a separate command and another command set b will be holding the value 100. For future reference, b can used as $b.

3.3.4 Quotes and braces

For example, consider the following script:

set x 10

set y 20

set z "$x + $y is [expr $x + $y]"

The value of z after the evaluation is 10+ 20 is 30. Everything command between the double quotes is passed to the set command as a single word. Note that a command and variable substitutions are performed on the text between the quotes; and the quotes themselves are not passed to the command. If the quotes in the above example were absent, the set command would have received 6 arguments, which would be an error.

Curly braces provide another way of grouping information into words. They are different from quotes in that no substitutions are performed on the text between the curly braces:

set z {$x + $y is [expr $x + $y]}

This command sets variable z to the value "$x + $y is [expr $x + $y]".

3.3.5 Looping and Control structures

Tcl provides almost all the control structures that were available with other programming languages. Tcl control structures are commands that take Tcl scripts as arguments.

if statements

if { test1 } {

body…..1

} elseif { test2 } {

Body…..2

} else {

Body….n

}

Example 3: Simple Example using if

puts "What’s your mark in Scripting Language"

gets stdin marks

if {$marks > 90} {

puts "Great, you got S Grade"

} elseif {$marks > 50 && $marks < 90} {

puts "Hey You passed the Exam"

} else {

puts "You need to improve your marks next time"

}

This code gives a simple example of if statement with conditional statements. This example also helps understanding that how to get the input from the user using gets stdin

For Loop

The for loop in Tcl takes the same format as of other languages like

for { initialization }{ condition } { increment or decrement }{

body

}

Example 4: Sum to N Terms

set x 10

set sum 0

for { set i 0 } { $i <= $x } { incr i } {

set sum [expr $sum+ $i]

}

puts $sum

The above example displaysthe sum of first 10 elements which is 55.

While Loop

The while loop syntax is as follows:

while { condition } {

Body of the loop

}

For example, here is a small code that helps in understanding while loops in a greater way

Example 5 – Squaring a number using while loop

set x 10

while { $x < 10 } {

puts [expr $x * $x ]

incr x

}

Like for and while, there are foreach and for…in loops are also used in Tcl programming. Since this book is being written for Network simulator 2 and its simulation objects, the readers are advised to learn more about Tcl programming in these books [1].

3.3.6 Procedures

A procedure is a block that contains series of commands. Functions in other programming languages are preferred as Procedures in Tcl. The Modularity of the program is maintained when procedures are used. Here are some of the pros of the procedures:

Reducing the code size by avoiding duplication
Groups in to simpler tasks rather than complex task
Reuse of code

There are user defined procedures and built in procedures. The keyword proc is used to define the user defined keyword.

Example 6 – Tcl Procedure Example

proc display {} { ; #This is the line to create a procedure using the command proc

set ns [expr 1 + 2] ; # evaluates the expression 1 + 2 and assign it to ns

puts $ns ; # display the value to the screen

}

display; #calling the procedure

the display procedure is called using display as given in the last line of the code. It is understood that this procedure does not contain any arguments or parameters.

Procedure with arguments

Procedures can also take arguments. The following examples show the procedure with single argument.

proc hello{f} { ; # f is the argument here

puts “Hello Mr. $f”

}

puts [hello “Pradeep”]

puts [hello “Amit”]

Output.

Hello Mr. Pradeep

Hello Mr. Amit

Next example with more than one argument, let us see an example to find out the biggest among three numbers. So there can be three arguments.

proc biggest { a b c } {

if {$a > $b && $a > $c }

return $a

} elseif {$b > $a && $b > $c} {

return $b

} else {

return $c

}

set a 10

set b 20

set c 30

set val [biggest $a $b $c]

puts “The biggest of $a, $b and $c is $val”

Procedures are the powerful commands in Tcl and it is very much useful in producing reusable codes that also reduces the code size.

3.3.7 Working with Files

Like other languages, Tcl also has file handling facility and it can open, read and write to files.

Syntax:

set nf [open file.txt w]

puts $nf “This is a simple example to write to a file

The file attribute can be

r – Open the file for reading and file should exist.

r+ - Open the file for reading and writing.

w – Open the file for writing, and if the file exists already, it will be overwritten, else a new file will be created.

w+ - open the file for reading and writing.

a - open the file for writing. If the file already exists, the cursor will point to the end of the file, if the file not exists, a new file will be created.

a+ - Open the file for reading and writing. If the file already exists, the cursor will point to the end of the file, if the file not exists, a new file will be created.

It is always a good practice to close a file once the job is done. The following code shows how to close the file. In Tcl programming, usually all the open handles like files, pipes, any global variables, etc can be closed at the end of the program.

set tracef [open file.dat a]

puts $tracef “This is an example to show the file close”

close $tracef

The file is opened in the append mode and if the file.dat is already existing, then the string “This is an example to show the file close” will be written to the end of the file.

Conclusion

This chapter informs the bits and pieces of Tcl programming to a limited level. Since this book is intended for Tcl files that are written for network simulation and hence limited information is provided for Tcl. The readers are advised to read the full-fledged tutorial for Tcl if they wanted to do extensive programming on Tcl.

OTCL and C++ Linkages with Example - NS2 Tutorial 3

2021-10-26T14:27:00.001+05:30

OTcl and C++ Linkages

In this post

The linkages between OTcl and C++ is covered.
The functions of various TclCL classes were explored.

Network simulator 2 (ns) deals with two different languages OTcl and C++. The OTcl is mainly for beginners that act as a frontend to test, analyze the components of networks. But C++ on the other hand runs in the background and usually deals with implementation of Queues, protocols, packets, agents, applications, etc. However when C++ modules are introduced, it is necessary to see how it is linking with the OTcl objects. This chapter deals this.

3.1 NS-2 Architecture

Network Simulator 2 (NS-2) deals with two different languages C++ and OTcl. Mainly OTcl is interpreted language and C++ is Compiled language.

The advantage of both the languages in NS2 is not compromised as both the languages have their own pros and cons.

OTcl

· Preferable for beginners (to start simulation even without knowing much about ns2)

· Runs in the front end. (Since interpreter is slow in execution, OTcl preferred in the front end)

· Interpretation is fast and execution is slow (Since it accepts changes fast, the source code can be modified easily to verify the network performance)

C++

· Mainly deals with implementation of network terminologies like queues, packets, agents, applications, routing algorithms, etc.

· Preferable for medium and advanced users

· Its execution is fast and compilation is slow. (Compilers usually are slow in compilation and hence they are running in the background to make the execution faster)

With these above, we can conclude that OTcl and C++ both need to be in their places for faster execution.

3.2 Code Overview

Consider the example:

set tcp1 [new Agent/TCP]

set sink1 [new Agent/TCPSink]

set udp1 [new Agent/UDP]

The above code is a Tcl code that calls TcpAgent, TCPSink Agent and FTP Application. All three are C++ modules that are executing in the backend.

These three Tcl Objects links with the C++ Objects as given in the Table

OTcl Object	C++ Class	Location of C++ file
Agent/TCP	TcpClass	~ns-2.35/tcp/tcp.cc
Agent/TCPSink	TcpSinkClass	~ns-2.35/tcp/tcp-sink.cc
Agent/UDP	UdpAgentClass	~ns-2.35/apps/udp.cc

As shown in the table, there should be a link between the OTcl and C++. NS-2 defines a interface called TclCL (~tclcl/) that contains some classes that makes the mapping between OTcl and C++.

There are some lists of classes and this chapter will be focusing on four main classes with their member functions. These classes are defined in ~tclcl-xx/Tcl.h. The following table lists the purpose of each class with their class names

Tcl	Contains method to access the interpreter
TclObject	This is the base class of all Simulated object libraries
TclClass	Provides the mapping between the classes of interpreted hierarchy and compiled hierarchy
TclCommand	Used to define the global interpreter command
EmbeddedTcl	Contains method to load the C++ commands for easier configuration
InstVar	Contains methods to access C++ member variables as OTcl instance variables.

The location of these classes are found in the ~tclcl/Tcl.[h, .cc], ~tclcl/Tcl2.cc, ~tclcl/tcl-object.tcl, etc. These classes are used in building ns.

Class Tcl

The class Tcl that contains methods to access the interpreted hierarchy. The methods can be used by the programmer to develop the C++ code.

Class Tcl provides the following operations

· Obtain a reference to Tcl instance

o Tcl& tcl = Tcl::instance();

o tcl is the reference and all the methods can be accessed using tcl.eval(), tcl.evalf(), etc.

· Invoke Tcl procedures

o Four methods are there to invoke the command through the instance tcl.

o tcl.eval() -

o tcl.eval(char* a) – executes ‘a’ through the interpreter.

o tcl.evalf(const char* a…..)- this is similar like a printf() statement where the format specifiers are used.

o tcl.evalc(const char* a)- it preserves the argument string ‘a’ as a constant.

Example:

tcl.evalf(“%d is the packet id”, packet_id);

tcl.evalc(“put this to the screen”);

· Passing Results to/from the Interpreter

o Two functions are used to pass results to/from the interpreter.

o tcl.result(const char* a) – pass the string a to the interpreter back.

o tcl.resultf(const char* fmt, ...)

o the following script will help you on this

if (strcmp(argv[1], "HELLO") == 0)

{

tcl.resultf("%d", seq_no);

return TCL_OK;

}

tcl.result("Invalid operation specified");

return TCL_ERROR;

· Error Reporting and Exit

o Errors are often reported to the interpreter using the function error().

o tcl.error(const char* a) performs the following functions:

§ write a to stdout;

§ write tcl_->result to stdout;

§ exit with error code 1.

· There are other operations and hash Functions within the Interpreter, they are

o tcl.enter(TclObject* o) – to insert an object in the hash table while creating the TclObject

o tcl.lookup(char* a) will retrieve the TclObject with the name a.

o tcl.remove(TclObject* o) will delete references to the TclObject.

o These functions are used internally by the class TclObject and class TclClass.

Class TclClass and Class TclObject

TclClass is a pure virtual class. Classes derived from this base class provide two functions:

· It does the mapping between the classes of interpreted hierarchy and compiled hierarchy;

· This class provides methods to create instance for TclObject.

// ~ns-2.35/tcp/tcp.cc

static class TcpClass : public TclClass {

public:

TcpClass() : TclClass("Agent/TCP") {}

TclObject* create(int , const char*const*) {

return (new TcpAgent());

}

} class_tcp;

As an example, consider the code segment above which shows the syntax of the TcpClass. It is derived from class TclClass, and is associated with the class TcpAgent. This will will create the instance of TcpAgent and thus create new objects in the class TcpAgent. The compiled class hierarchy for TcpAgent is that it derives from Agent, that in turn derives from TclObject.

Here is the observation from this deﬁnition:

· This TclClass defines only the constructor and it shows the compiled hierarchy.

· ns will execute the TcpClass constructor for the static variable class_tcp, when it is ﬁrst started.

· The constructor speciﬁes the interpreted class explicitly as Agent/TCP. This also speciﬁes the interpreted hierarchy.

· The convention in nsis to use the character slash (’/’) is a separator. For any given class A/B/C/D, the class A/B/C/D is a sub-class of A/B/C that is itself a sub-class of A/B, that, in turn, is a sub-class of A. and A is the sub class of TclObject. In our case above, the TclClassconstructor creates two classes, Agent/TCPsub-class of Agent sub- class of TclObject.

· The TcpClass::create method returns TclObject in the class TcpAgent.

· When the user speciﬁes new Agent/TCP in the tcl file, the class TcpClass::create is invoked and thus a shadow object is created.

Consider the Example shown called as the Amplifier Agent that amplifies the given value in to multiples times

/* A Simple agent that does the amplification of a given value to 3 fold and more. The name of the agent is represented as TSPAgent as The SPecial Agent that does the amplification */

//Header file declaration

#include <stdio.h>

#include <string.h>

#include "agent.h"

class TSPAgent : public Agent {

public:

TSPAgent();

protected:

int command(int argc, const char*const* argv);

private:

int amp1, amp2, amp3;

void APrivateFunc(void);

};

static class TSPAgentClass : public TclClass {

public:

TSPAgentClass() : TclClass("Agent/AMPLIFY") {}

TclObject* create(int, const char*const*) {

return(new TSPAgent());

}

} class_tsp_agent;

TSPAgent::TSPAgent() : Agent(PT_UDP) {

bind("Ampli1", &amp1);

bind("Ampli2", &amp2);

bind("Ampli3", &amp3);

}

int TSPAgent::command(int argc, const char*const* argv) {

if(argc == 2) {

if(strcmp(argv[1], "call-the-private-function") == 0) {

APrivateFunc();

return(TCL_OK);

}

return(Agent::command(argc, argv));

}

void TSPAgent::APrivateFunc(void) {

Tcl& tcl = Tcl::instance();

tcl.eval("puts \"Message From the Private Function\"");

tcl.evalf("puts \" The Amplified Value is %d and the factor is 2 \"", amp1*amp1);

tcl.evalf("puts \" The Amplified Value is %d and the factor is 3 \"", amp2*amp2*amp2);

tcl.evalf("puts \" The Amplified Value is %d and the factor is 4 \"", amp3*amp3*amp3*amp3);

}

In the above example, the Line 1 to 3, includes the header files, the Agent class is available in the agent.h file.

Line 5 to 13, declares a class with three integer variables and two functions command() and APrivateFunc().

Line 14 to 19, includes a static class that does the mapping between the OTCL and C++ and also contains the code that instantiates the TclObject. The name of the Agent here is Agent/AMPLIFY which indicates it is a interpreted hierarchy and the static class TSPAgentClass is the compiled hierarchy class. Clearly, the TclClass does the mapping between the Interpreted hierarchy and Compiled hierarchy.

Line 20 to 24, declares the constructor and all the agents should act on a Packet, so this agent acts in the UDP Packet, PT_UDP. There are three binding OTCL factors Ampli1, Ampli2 and Ampli3 that maps to C++’s amp1, amp2 and amp3respectively.

Line 25 to 31, implements the command function, that processes the arguments passed from the OTCL. If the argv[1] and the call-the-private-function is validated, that calls the APrivateFunc();

Line 32 to 38, the implementation of APrivateFunc() that amplifies the values.

Here is the Tcl file to test the above agent

#the name of the file is agent.tcl

set myagent [new Agent/AMPLIFY]

$myagent set Ampli1 3

$myagent set Ampli2 4

$myagent set Ampli3 5

$myagent call-the-private-function

To execute the above agent, here are the steps

· Copy the ampagent.cc file in ~ns-allinone-2.35/ns-2.35/newagent

· Make an entry in the ~ns-2.35/Makefile.in

Make an entry in the OBJ_CC =

newfolder/ampagent.o \

· In the shell prompt, go to ~ns-2.35 and give the following commands one by one

./configure

Make

· Run the file agent.tcl

· If warnings are there, the set the default values in the ns-default.tclfile (~ns-2.35/tcl/lib) as shown below

o Agent/AMPLIFY set Ampli1 1

o Agent/AMPLIFY set Ampli2 1

o Agent/AMPLIFY set Ampli3 1

Output:

Message From the Private Function

The Amplified Value is 9 and the factor is 2

The Amplified Value is 64 and the factor is 3

The Amplified Value is 625 and the factor is 4

Network Simulator 2 - Simple Example - NS2 Tutorial 2

2021-10-26T14:18:00.006+05:30

Introduction to Network Simulator 2

In this post

Introduction to Network Simulator 2 and its architecture
Installation of Network Simulator 2 in various Operating Systems
How to simulate a given network with available libraries of NS2

The network simulator 2 (ns) addresses large number of protocols, applications, agents, queues, etc. These are called as “simulated objects” either in the C++ or OTCL. This book will let the users to code the ns Tcl scripts for wired and wireless networks. This book is intended for students, researchers who need better understanding of networks.

NS is a discrete event simulator developed towards the research and development in networking. NS supports various supports on wired, wireless networks, protocols, unicast/multicast networks, satellite networks. The recent versions of ns2 support latest wireless networks.

NS evolves in 1989 as REAL network simulator. Later in the year 1995 ns development was supported by DARPA through the VINT project at LBL, Xerox PARC, UCB, and USC/ISI.

While ns is favorable to researchers right through the inception it is still not a finished or a polished product. Still the bugs are being discovered and corrected by the researchers. Sometimes the simulations may be invalidated by the bugs. Users are responsible for verifying themselves to correct these.

The main purpose of this book is to provide the readers the basic knowledge and architecture on ns2. This book provides with Tcl scripts for various networks that were available as modules within ns2. The best way to start learning NS2 is through the Ns Manual [1] provided by the http://www.isi.edu/nsnam/ns. However, this book will help you to simulate these networks that were available in ns2 software.

Installation of NS2

NS2 uses two languages OTCL and C++, in which OTCL provides the front end and C++ runs in the backend. For more details, please refer Chapter 3.

OTCL is

· Interpreted language also called as interpreted hierarchy

· OTcl is Object Oriented Tcl

· Preferable for beginners to simply test the protocols, wired, wireless networks, etc

· Interpretation is fast and execution is slow (so prefer to run in the front end)

C++

· Compiled hierarchy

· Preferable when dealing with packet, agent, application, protocol, routing, etc.

· Compilation is slow, but execution is faster (so prefer to run in the backend)

TclCL is

· Provides some classes for interfacing between C++ and OTcl

· Consists of classes with methods Tcl and members to does the mapping between the other two languages.

The fig1.1 will describe the same.

NS2

Fig 1.1 – Architecture of NS2

As shown in the fig1.1, the input is the Tcl script and the output is to plot the graph or animate the network.

· Develop the .tcl file.

· Execute the file using ns filename.tcl

· There are two output files

· A file with nam as extension to show the animation

· To execute the nam file, nam filename.nam

· A file with .tr or .xg or any other as specified to plot the graph and to identify the performance characteristics

· To see the graph, either to use xgraph or tracegraph or gnuplot

· The trace file can also be processed using awk script by analyzing the text information from the file and predict the performance metrics of the networks

Directory Structure of NS2

This book deals with the latest ns package with version 2.35. The NS is a free tool that can be downloaded from [3]. It can be installed on various operating systems like Linux, Unix, Mac Systems, Windows, etc. This book unless otherwise specified, uses Linux as the Operating System for using NS2.

NS comes with two different forms,

· All in one package

· The current version is ns-2.35

· The various packages comes along with the allinone package

· nam-1.15

· ns-2.35

· otcl-1.14

· tcl-8.5.10

· tk-8.5.10

· tclcl-1.20

· xgraph-12.2

· All these packages comes in a single bundle and it contains a install script that compiles all the packages using the make utility and generate the binaries for ns, nam, xgraph, etc.

· Component wise package suite

· In this all the packages have to be compiled separately

NS2 has the directory structure with ns-allinone-2.35 is the top level and there are subsequent levels. The fig 1.2 shows the directory structure of ns-2.35

NS2 Directory Structure

The ns-2.35 folder contains all the simulated modules in the compiled form and there are so many other folders within the ns-2.35. If anyone is working on the networks, then they can retain themselves within this ns-2.35 directory, because that contains almost everything related to the network.

Some other folders of use are

· Ns-2.35 /

· aodv – that contains the code of the routing algorithm AODV

· dsdv – contains the code for the routing DSDV

· mac – contains all the mac layer codes , Ex. 802.11, etc

· queue – codes that contain all the queuing nodes

· mobile – information about the mobile parameters of the node.

· tcl – all the simulation modules in the interpreted hierarchy

· lib – all the TCL simulation objects

· ex – contains the tcl scripts for various networks

Installation of NS2 on a UNIX like platform

To install the ns2 software on a UNIX like platform, the install script has to be executed using the make utility

Shell> ./install

To install all the required software and to create the binaries.

Shell> ./validate

This is to validate the all the required functionalities that were installed during the ./installprocess.

Please refer, Appendix A for detailed installation instructions for most of the Operating systems.

Starting with NS2

Starting with ns, the user need to know lot many things. Listed are some important ideas and techniques before proceeding to program ns.

· set tcp1 [new Agent/TCP]

· In the above statement, [new Agent/TCP] creates a shadow object from the TcpClass Agent class.

· When this statement is dealt with, there are many parameters to be noted.

· Where is the actual agent (in which source file the agent was written).

· TcpClass was written in C++ and the code is located at ~ns-2.35/tcp/tcp.cc

· When new Agent/TCP is called in OTCL, the TcpClass runs in the backend and thus creates a shadow object which returns the TcpAgent.

· There are many parameters executes when the agent is created. TcpAgentalso has many parameters initialized and modified during the simulation of network. However, not all the parameters are relevant for the research when simulating the network.

· All those parameters default values are located in the ~ns-2.35/tcl/lib/ns-default.tcl file. These values can be overwritten within the tcl script when the user is writing.

· For example, Agent/TCP set numdupacks_ 3 (this is the line taken from the ns-default.tcl file and specifies that the number of duplicate acknowledgment is 3 and if the user wanted to change it to 5, the code has to be included in the tcl file like this

· $tcp0 set numdupacks_ 5 (as tcp0 is the handler for the Agent/TCP)

· There may be more number of C++ classes running in the background when the Tcl file is interpreting and the researchers are advised to go through the source code if they are programming a given network.

The following table tells the Agent name and their corresponding file location.

Agent/TCP	TcpClass	~ns-2.35/tcp/tcp.cc
Agent/TCP/Reno	RenoTcpClass	~ns-2.35/tcp/tcp-reno.cc
Agent/UDP	UdpAgentClass	~ns-2.35/apps/udp.cc

Table 1.1 – Otcl - C++ Class names

Let us go through a simple example of a wired network that exchange packets between the nodes.

Two wired Nodes

Listing 1.1 – TCP with FTP Traffic between two nodes

#create a new simulator object ns

set ns [new Simulator]

# creation of two nodes n0 and n1

set n0 [$ns node]

set n1 [$ns node]

#Open the files for tracing in write mode, if the file already exits, it will be overwritten, else a #new file will be created

set tracefile [open out.tr w]

$ns trace-all $tracefile

#Open the files for network animation

set namfile [open out.nam w]

$ns namtrace-all $namfile

#Create a duplex link between nodes n0 and n1

$ns duplex-link $n0 $n1 2MB 10ms DropTail

#Creates TCP Agent and attach it to node 0

set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0

#creates TCP Sink Agent and attach that agent to node 1

set tcpsink0 [new Agent/TCPSink]

$ns attach-agent $n1 $tcpsink0

# Set the Traffic for FTP and attach it to TCP Agent

set ftp [new Application/FTP]

$ftp attach-agent $tcp0

#connect the source and the sink

$ns connect $tcp0 $tcpsink0

#Start the traffic at 1.0seconds.

$ns at 1.0 "$ftp start"

#call the finish procedure at 4.0 sec

$ns at 4.0 "finish"

#Procedure finish{}

proc finish {} {

global ns tracefile namfile

exec nam out.nam &; #execute the animation within the procedure

exit 0

}

#Run the simulation

$ns run

Conclusion

This chapter gives you the short glimpse of what is ns2 and how it is installed under various operating system. This chapter deals with the directory structure of ns2 with various other packages that are of important to Network simulator for its operation. Also this chapter shows the two languages used in ns2 OTcl and C++ and demonstrates a wired Tcl script with Network animation screenshot.

Introduction to NS2 - NS2 Tutorial 1

2021-10-26T14:10:00.002+05:30

Introduction to Network Simulations

In this post, you can learn

Introduction to Network Simulator 2 and its architecture
Installation of Network Simulator 2 in various Operating Systems
How to simulate a given network with available libraries of NS2

A simulator is of extensive use to engineers and researchers as it provides them a simple and inexpensive way to test the real world scenarios without facing the problems of actual implementation, though getting the same results. Similarly, a network simulator is software which models the behavior of the network given to it as an input, under real network characteristics without the actual network being present. To generalize, we can say that a simple network simulator must provide the user the capability to create nodes, the links between them and the traffic between the nodes. Additionally, an advanced network simulator may provide options for specifying every detail about the protocol used in handling network traffic.

Simulation is the modelling of an environment which is exactly similar to the underlying state of the target. The main goal of building a simulator is that, the internal state transitions and responsiveness of the system must exactly match the actual target environment it’s trying to mimic. Simulators are often used in order to give the user an initial experience of the real environment, since it may not be feasible for the user or the corporation to let the trainee use the actual environment due to monetary or safety reasons. The best example of a simulator is the flight simulator. The pilot trainee is never allowed to board the actual cockpit until he is able to get through the flight simulator environment. The flight simulator has the exact controls which is present in the cockpit and creates a virtual environment similar to that of the actual cockpit. It is capable of taking into consideration a number of factors like G-Forces, turbulence etc. It’s mandatory that these effects are very accurate so that the pilot doesn’t make any errors during the actual flight. Like wise, network simulators are useful in analysing, testing and design of various methods of computer networks. The emergence of wireless networks forced network simulations to be more accurate and appropriate due to its dynamic nature while deploying such networks.

1.1 Need for Simulation

Most of the pilot projects are using simulators rather than the real network deployments because of various factors like cost, implementation difficulties, customization, new technology adaptation, etc.

However there are situations where the real networks deployment are at upper hand for accurate results and it is the actual thing happening. Here is a simple comparison between the real model and the simulated model.

Real Network	Simulated Model
The cost of all the network components have to be procured	Most of the simulators are open source and free and cost is zero. (Example, NS2, OMNeT++, etc)
Time to set the things is really a painful task. (For Example, configuring a switch, hub or a router involves a skilled worker)	Learn a programming tool to model the devices once. Once learned, setting a network is a very simple task
Altering a given component may incur additional devices to setup or malfunction the entire network setup.	There is no risk while changing or altering the pre existing network.
This is the actual thing happening and whatever results you get the results are real and accurate.	Here also one may get accurate results until the system is bug free. If there are bugs in the system, the results may be unreliable or inaccurate.
Overall: Cost is high and exact results.	Overall: Cheaper and easier to deploy and development

So once the network project is decided, it is advisable to look for a simulator rather than option for a real network deployment as the initial cost should in any case be minimal.

1.2 List of Network Simulators

There are various simulators available for simulations each with their own purpose. However there are limited simulators that support wide range of protocols, routing metrics, etc. Here is the list of simulators that support huge number of protocols and network entities.

Network Simulator 2 [NS2]

Network simulator 2[3] is one of the oldest simulator available for simulation of wired, wireless, satellite networks, etc. For more than a decade, it satisfies most of the researchers/students across the globe in simulating the networks. It has a strong community that helps developers, researchers across the internet. NS2 was criticized because of the complex architecture it has (OTcl and C++), but it supports the oldest to latest the protocol that were available for the wired or wireless networks. NS2 is completely open source and free.

Network Simulator 3 [NS3]

NS3 [14] is another simulator available for less than a decade and it supports network components of recent developments, unlike NS2, the architecture of ns3 is simpler and one can simulate a network using either C++ or python scripts. NS3 is evolving these days to a greater extent and will come with new protocols, new networks, etc in each of their releases. NS3 is completely open source and free.

OMNeT++

OMNeT++[15] another tool that supports many protocols, network entities using the framework INET which is coming as a third party interface. OMNeT++ is built on the eclipse framework and the development and deployment is very easy as it as a richer GUI that supports the developers to form a network very easy. It is built over C++ and most of the developmental modules are developed in C++ and there is a configuration file (omnetpp.ini) which solves the purpose of forming a network either in a text mode or in a graphical mode. All these things available at a free cost. OMNEST is the commercial version.

OPNET

This is expensive commercial software available for network simulation and is available with source codes for unrestricted protocols. Trial version is available on request. It contains excellent manual. It has a full-fledged GUI with XML based support for scenario generation. Because of its heavy weight components, this is a slow simulator.

There are various other simulators too in the market that solves the purpose of narrow network research. So, the developers once identified a network, there are choices available for them to select the perfect simulator for their research. The following table will list some of the key comparisons between the simulators

Name	OPNET	NS2	NS3	OMNeT++
Cost	Highly expensive.	Free and Open Source	Free and Open Source	Academic Version is Free
Support	Good manual with source codes	Proper documentation	Proper documentation	Documentation is available
Topology/Scenario	GUI	OTcl	C++ or Python	GUI with omnetpp.ini
Languages/scripts used	C++	OTcl and C++	C++ and Python	C++
Forum /Community Help	Less	Best	Good	Good
Overall Rating	Expensive and highly commercial, simulation is also slow, suited best for the industries	Best for latest and faster simulations	Best for latest and faster simulations	Need for a third party framework for a given network. Also issue with version compatibility

1.3 Time driven and Event Driven Simulations

Usually network simulations carried out either in time driven or event driven. Each of them have their own pros and cons. This topic will show you the difference between these simulations.

Time driven Simulation

Time driven simulation is also called as discrete time simulation. The simulation is carried out on a fixed time interval. The time interval in which a task is running is assumed to be running before the end of the interval though the task would have arrived at the beginning of the interval.

For example:

Assume ∆t is the interval in which the task is running (Assuming a packet arrives in ∆t)

∆t = t2- t1.

Suppose if the packet arrives t1+0.001 and it may be running before the time t2. So sometimes, the packet may have to wait for a shorter duration of time because of this kind of simulation.

A simple pseudo code shows

For t = 1 to time

{

If (packet arrival)

Buffer ++;

Else (packet departure)

Buffer—

Print (Buffer);

}

This shows the time driven simulation has some limitations in networks.

Event driven Simulation

Event driven simulation as the name says, it handles some set of events using a scheduler or a handler. Here are some of the key features of event driven simulation

Discrete set of events can be handled by a scheduler
One event upon completes triggers the next events
The events are fired as random intervals and are scheduled by the handler
The simulation may be stopped once all the events are executed or at a predefined time (where we want to end the simulation). In short, the stopping occurs when the system reaches a particular state or particular time.

Here is the pseudo code for Event driven simulation

Initialize the system

Initialize the events

While (true)

Collect information from the current event.

Remove first event from the list and handle it.

Set time to the event

When compared event driven simulation has upper hand over the time driven simulation as in the latter case, the time is wasted in difference of timing. But selecting a small ∆t does not solve the purpose as the computational complexity of handling the network dynamics may not suite.

This book is demonstrates the Network Simulator 2 (NS2) which is a discrete event simulator that handles the network dynamics using discrete number of events that are handled by a scheduler. Also ns2 supports four different types of scheduler namely calendar (Default), heap, simple linked list and real time scheduler.

1.4 Modeling for Network Simulation

The most difficult part in simulation of network is the selection of a Model. Selecting a model needs the thorough knowledge of network elements, problem specification and the deep knowledge of the system under study. So, to analyse a given network under study, here are steps that can be used for performance analysis [16]

Problem formulation and system model definition
Performance Metrics definitions
Various levels under study
Data collection
Selection of simulation environment
Verification and validation
Experimentation and analysis

1.5 Conclusion

This chapter deals with the elements of network simulation that compared time driven and event driven simulation. Also this chapter tells the list of network simulators that are available for research and development. This chapter compares various simulators based on their usage and features.

Installing ns-3.34 in Ubuntu 20.04

2021-07-30T10:37:00.003+05:30

This post shows how to install ns 3.34 in Ubuntu 20.04 LTS

Prerequisites:

Fresh installation of Ubuntu Version 20.04 LTS
ns3.34 can be downloaded from here

Follow the video link for complete step by step instructions on the installation.

This version fixes the compilation issues of vanet-routing-compare.cc (bug in ns3.33)

Issue the following commands after opening a terminal

$ sudo apt update

$ sudo apt install g++ python3 python3-dev python-dev pkg-config sqlite3 python3-setuptools git qt5-default gir1.2-goocanvas-2.0 python3-gi python3-gi-cairo python3-pygraphviz gir1.2-gtk-3.0 ipython3 openmpi-bin openmpi-common openmpi-doc libopenmpi-dev autoconf cvs bzr unrar openmpi-bin openmpi-common openmpi-doc libopenmpi-dev tcpdump wireshark libxml2 libxml2-dev

Unzip or untar the ns-allinone-3.34.tar.bz2 in the home folder (in my case its /home/pradeepkumar)

$ cd ns-allinone-3.34/

$ ./build.py --enable-examples --enable-tests

Once the installation is completed, you may get an output shown as below

ns-3.34 in Ubuntu 20.04

The following packages are installed

Visualizer

NetAnim

Python Bindings

Wireshark

ns3

GNU Scientific Library IEEE 802.11b

MPI

Please subcribe to my channel and share it to your friends..

There is membership options as well for my channel.

Thanks for watching...!!!!

In case, if you want to contribute to my work on Engineering Clinic, You can be part of my channel as a member.

Join my channel to get access to perks: https://www.youtube.com/channel/UCSckTbBIf39jf2dIbruS32A/join

VANET-routing-compare error in ns-3.33

2021-07-20T16:39:00.005+05:30

In network simulator 3, while simulating the vanet-routing-compare.cc file, you may get an error in ns-3.33 version as shown below:

msg="GlobalValue name=VRCcumulativeBsmCaptureStart: input value is not a string",

file=../src/core/model/global-value.cc, line=128
terminate called without an active exception
Command ['/home/ns3/Desktop/ns-allinone-3.33/ns-3.33/build/scratch/vanet-routing-compare'] terminated with signal SIGIOT. Run it under a debugger to get more information (./waf --run <program> --gdb").

To overcome this error, here is the patch to download

https://github.com/tspradeepkumar/ns3/blob/main/vanet.patch

Once downloaded, move this file to

~ns-3.33/scratch/ folder and copy the vanet-routing-compare.cc also to the scratch/ folder and apply the following command

$ cd ns-allinone-3.33/ns-3.33/scratch

$ patch -p0 < vanet.patch vanet-routing-compare.cc

Check the following video for explanation of vanet-routing-compare.cc and its characteristics.

Please find the screenshot of the action:

ns-3.33 vanet

vanet-routing-compare.cc in ns-3.33

MQTT using Node JS | Node JS Tutorial

2021-07-20T15:43:00.006+05:30

This post shows you Simple MQTT Application using Node JS. There are three parts of the application.

For running any MQTT application, we need a

1. Broker (The broker can be anywhere in the Internet or cloud or a local machine)

2. Publisher (pub.js is the name of the file)

3. Subscriber (sub.js is the name of the file)

Check the following video for complete instructions.

In this example, we will be using a broker called https://www.hivemq.com

To use the cloud broker (mqtt://broker.hivemq.com) and connect the publisher and subscriber with a topic and a message. To install the Hive MQ software in your local machine (127.0.0.1) and run the same above code locally and make the connectivity between the pub-sub.

We open two new .js files called pub.js (publisher) and sub.js (subscriber) in Visual Studio Code. To install the mqtt module in NodeJS, we use the command “npm install mqtt” in C:/ terminal.
We define our client as connecting to “mqtt://broker.hivemq.com”. We connect to the cloud broker in both publisher and subscriber js modules. We have taken temperature and temperature value as our message. The source code is given below.
To execute our code, we open two terminals and use the command “node pub.js” and then in the other one, “node sub.js”. In the left command prompt, we have published, and in the one on the right, we have subscribed. We can see the outputs match each other.

MQTT using Node JS

Using cloud broker:

Pub.js:

const mqtt = require("mqtt");

var client = mqtt.connect("mqtt://broker.hivemq.com");

client.on("connect",function()

{

setInterval(function(){

var random = Math.random()*50;

console.log(random);

if(random<30)

{

client.publish("Pradeep","temperature value: "+random.toString());

}

}),30000;

});

Sub.js:

const mqtt = require("mqtt");

var client = mqtt.connect("mqtt://broker.hivemq.com");

client.on("connect",function()

{

client.subscribe("Shirish");

console.log("Client subscribed ");

});

client.on("message",function(topic, message){

console.log(message.toString());

});

Using local broker:

To run the broker locally, we first install HiveMQ on our system.

HiveMQ for MQTT

Pub.js:

const mqtt = require("mqtt");

var client = mqtt.connect("mqtt://127.0.0.1:1883");

client.on("connect",function()

{

setInterval(function(){

var random = Math.random()*50;

console.log(random);

if(random<30)

{

client.publish("Shirish","temperature value: "+random.toString());

}

}),30000;

});

Sub.js:

const mqtt = require("mqtt");

var client = mqtt.connect("mqtt://127.0.0.1:1883");

client.on("connect",function()

{

setInterval(function(){

var random = Math.random()*50;

console.log(random);

if(random<30)

{

client.publish("Shirish","temperature value: "+random.toString());

}

}),30000;

});

Installation of ns3 in Windows 10 and Windows 11 OS using WSL (Windows Subsystem for Linux)

2021-05-16T13:08:00.006+05:30

This post shows how to install ns-3.33 in Windows 10 through WSL (Windows Subsystem for Linux)

This posts works for Windows 11 also (I have tested it on a Windows 11 ISO and it works the Same way as mentioned in the following post.)

This post will work for ns-3.3x version.

Prerequisites:

Install Windows Subsystem for Linux with GUI: Please refer the following video

System Information:

OS used: Windows 10 and WSL (Ubuntu 20.04)

GUI: XServer for Windows

NS3 Version: ns-3.33

See the following complete video on how to install ns3 in Windows 10

Step 0 : Open XLaunch

Step 1 : Open WSL using PowerShell and open it as Administrator

Command:/ wsl

$ xfce4-session

The GUI of Ubuntu Opens within Windows 10 OS.

Step 2 : Download ns3 from nsnam.org website through Mozilla Firefox browser

Step 3: Open a Terminal

$ sudo apt update

$ sudo apt install build-essential autoconf automake libxmu-dev python3-pygraphviz cvs mercurial bzr git cmake p7zip-full python3-matplotlib python-tk python3-dev qt5-qmake qt5-default gnuplot-x11 wireshark

Step 4: Move the ns3 file from Downloads/ folder to Home folder (/home/pradeepkumar) and unzip it there itself, Right Click -- Extract Here

Step 5: Go to the terminal that is already open and issue the following commands

$ cd

$ cd ns-allinone-3.33/

$ ./build.py --enable-examples --enable-tests

It might take 10 to 20 minutes for installing, may be in between there might be errors as well.

Once the installation over, check for the following command for the working of ns3.

$ cd ns-3.33

$ ./waf --run hello-simulator

Also check for first.cc file, move the file from ns-3.33/examples/tutorial. folder to ns-3.33/scratch folder

$ ./waf --run scratch/first

You should get 4 lines of output between the client and server interaction

Then you can try for NetAnim as well as per the video.

In the first.cc file, include the following lines so work for NetAnim

#include "ns3/netanim-module.h"

and the following line above the Simulator::Run() function

AnimationInterface anim("first.xml");

After the above changes, compile the file again using

$ ./waf --run scratch/first

A file named first.xml would have created and it can be opened using NetAnim. To run NetAnim, try the following:

Open a new Terminal

$ cd ns-allinone-3.33/netanim-3.108/

$./NetAnim

Open the first.xml file and you can check the output.

Thanks are watching and please subscribe to my channel and share it to your friends....

How to install Ubuntu within Windows 10 without a Virtual Machine (VM) | WSL

2021-05-15T10:13:00.004+05:30

This post shows you how to install Windows Subsystem for Linux (WSL) in windows 10 operating system.

Requirements:

Windows 10 OS or Preview Release version of Windows 10. Refer the complete video below on how to install WSL in Windows 10 including how to use Full Linux GUI using XServer for Windows,

Follow the video for more details on how to do this process:

Installing WSL

There are multiple steps involved as given below

Step 1: Open Windows Power Shell from the Start Menu with Administrative Privileges

and execute the following commands

Command prompt:/> dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

Command prompt:/> dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Step 2: Restart your computer (This step is mandatory)

Step 3: Download the Linux Kernel Update package for x64 Machine

https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi

Double click the above downloaded file and install it. Click Yes if it asks for elevated privileges

Step 4: Set WSL2 as the default version

Command prompt:/> wsl --set-default-version 2

Step 5: Install the Linux Distribution of your choice: In MY case I have selected the following link. Its Ubuntu

https://aka.ms/wslstore

If the above link is not working, then

Open Windows Store and search for Ubuntu and select as per the screenshot given below

WSL Ubuntu

After the downloading and installation of the above software, a new command window opens and asks you to enter the preferred username and password for your linux Login. Input both and you are done.

Step 6: Using WSL

Whenever you want to use Ubuntu within your windows OS, open Power shell and execute the command

C:/> wsl

It goes into Linux mode and all the linux commands will work now

Use the following commands to update your system

$ sudo apt update && sudo apt -y upgrade

$ sudo apt install build-essential autoconf automake libxmu-dev net-tools

$ sudo apt install xrdp -y && sudo systemctl enable xrdp

Step 7: Enabling the GUI for Ubuntu within Windows

By default, WSL does not support any GUI, but there are some workaround to support the GUI like xubuntu-desktop or mate desktop, you can use either of these.

Open the Powershell

Command Prompt:/> wsl

$ sudo apt install -y tasksel

$ sudo tasksel install xubuntu-desktop

$ sudo apt install gtk2-engines

$ nano ~/.bashrc

and paste the following texts in the above file

export DISPLAY=$(cat /etc/resolv.conf | grep nameserver | awk '{print $2; exit;}'):0.0export LIBGL_ALWAYS_INDIRECT=1sudo /etc/init.d/dbus start &> /dev/null

Also create another file as per the command

$ nano /etc/sudoers.d/dbus

and paste the following line in this file. The username for ubuntu is pradeepkumar in my case, you can use your username in the following statement.

pradeepkumar ALL = (root) NOPASSWD: /etc/init.d/dbus

Step 8: Download the XServer for Windows 10 (which is free) and helpful in running Ubuntu's GUI applications within Windows.

https://sourceforge.net/projects/vcxsrv/

Install it by double click and open it afterwards (XLaunch), and follow the below settings as per the screenshots.

Final Steps:

Once all the above steps are completed, restart your Windows Machine and from then on, use the following for working with ubuntu:

To open ubuntu from windows, Follow these steps

Open Powershell or Command prompt (either in Administrator mode or normal mode) and type

Command Prompt:/> wsl

and thats it you are entering the ubuntu OS.

if you want to login with full Linux desktop, use the command

Command Prompt:/> xfce4-session

Its good and very powerful, lets use Ubuntu within Windows 10 without any hassles.

Please subscribe to my channel and share the video to your near and dears....

My YouTube Channel is :

https://www.youtube.com/tspradeepkumar

NB: I Used the following two links for the above procedure

Install WSL on Windows 10 | Microsoft Docs

The complete WSL2 + GUI setup. | Medium

BonnMotion - A mobile scenario Generator Tool

2021-04-20T09:46:00.000+05:30

BonnMotion is a tool that generates scenario for ns2, ns3, qualnet, etc. This will comfortably work with Linux. And in windows, there could be some bugs.

Please refer the documentation here: http://sys.cs.uos.de/bonnmotion/doc/BonnMotion_Docu.pdf

To use this tool for ns2, here are the steps.
Step1 : Download the BonnMotion tool from this website
Step 2: Unzip it to home folder (/home/pradeepkumar in my case)
step 3: Here are the commands to install
$] unzip -d bonnmotion-2.1.3.zip
$] cd bonnmotion-2.1.3/
$] ./install
The above command will install, if any packages are missing for dependencies, please install it.

$] Once installed, copy the bonnmotion-2.1.3/bin/bm file to /usr/bin/ for running it anywhere. if not go to bin folder using the command given below

$] cd bonnmotion-2.1.3/bin/

To run BonnMotion
$bonnmotion-2.1.3/bin] ./bm -hm
(this will list all the models)

$bonnmotion-2.1.3/bin] ./bm -hm RandomWaypoint
Will display all the parameters for RandomWaypoint like number of nodes, x, y, random seed, etc.

Assuming RandomWaypoint is the model

$bonnmotion-2.1.3/bin] ./bm -f scenario RandomWaypoint -n 10 -x 500 -y 500
The above command will create a file called scenario with 10 number of nodes with x and y as 500x500)

$bonnmotion-2.1.3/bin] ./bm NSFile -f scenario
This will create two files called scenario.ns_movements, scenario.ns_params

The above two files can be used inside tcl script for ns2 using the source command

source scenario.ns_params
source scenario.ns_movements

(NB: Please note that the above two files represents nodes like $node_(0), etc and $ns_ as simulator object, either you change these variables within your tcl file or edit the above two files. Also scenario.ns_params file shows the stop script as set val(duration) 600.0, but most of the tcl scripts may have val(stop), so change it to val(duration) in all cases)

The same will be applied to other simulators also, refer the documentation given in the beginning of the slide.

Some screenshots for you.:

Installing Bonnmotion

bm command with options

A Sample Tcl file using the script generated by BonnMotion

Download the sample files here: put all the files in a single folder and run the tcl file using
$] ns ex.tcl

Provide your comments below, if you need any queries.

Credits to: http://sys.cs.uos.de/bonnmotion/index.shtml

T S Pradeep Kumar

Link State Routing in NS3 - Wired Network

2021-04-12T22:21:00.005+05:30

Link state routing in ns3

There are two varieties of protocols that deals with wired networks namely distance vector routing and link state routing,

As per the wikipedia, Distance-vector routing protocols, which work by having each node share its routing table with its neighbours, in a link-state protocol the only information passed between nodes is connectivity related. Link-state algorithms are sometimes characterized informally as each router, "telling the world about its neighbors.

This exercise can be one of the lab exercises of many universities in India. There are many more exercises to follow. If one understand this video, they can able to simulate any network design and run it successfully in ns3.

In this blog post, I am not going to explain the concepts of link state routing, but will explain how to configure the nodes to use link state routing in ns3.

Please find the video for the source code explanation and compilation in ns3 on link state routing protocol

Here is the step to run the LSR and compile it to get the details.

Scenario is

Link State Routing (LSR)

Here is the source code from GITHUB https://github.com/tspradeepkumar/ns3

else you can copy from here:

//Link state routing for Wired Networks, OLSR
#include <iostream>
#include <fstream>
#include <string>
#include <cassert>

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/olsr-helper.h"
#include "ns3/ipv4-static-routing-helper.h"
#include "ns3/ipv4-list-routing-helper.h"

#include "ns3/netanim-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("SimplePointToPointOlsrExample");

int
main (int argc, char *argv[])
{
Config::SetDefault ("ns3::OnOffApplication::PacketSize", UintegerValue (210));
Config::SetDefault ("ns3::OnOffApplication::DataRate", StringValue ("448kb/s"));

CommandLine cmd;
cmd.Parse (argc, argv);

NS_LOG_INFO ("Create nodes.");
NodeContainer c;
c.Create (5);
NodeContainer n01 = NodeContainer (c.Get (0), c.Get (1));
NodeContainer n14 = NodeContainer (c.Get (1), c.Get (4));
NodeContainer n43 = NodeContainer (c.Get (4), c.Get (3));
NodeContainer n30 = NodeContainer (c.Get (3), c.Get (0));
NodeContainer n02 = NodeContainer (c.Get (0), c.Get (2));
NodeContainer n23 = NodeContainer (c.Get (2), c.Get (3));

// Enable OLSR
NS_LOG_INFO ("Enabling OLSR Routing.");
OlsrHelper olsr;

Ipv4StaticRoutingHelper staticRouting;

Ipv4ListRoutingHelper list;
list.Add (staticRouting, 0);
list.Add (olsr, 10);

InternetStackHelper internet;
internet.SetRoutingHelper (list); // has effect on the next Install ()
internet.Install (c);

// We create the channels first without any IP addressing information
NS_LOG_INFO ("Create channels.");
PointToPointHelper p2p;

p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
NetDeviceContainer nd01 = p2p.Install (n01);

p2p.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("10ms"));
NetDeviceContainer nd14 = p2p.Install (n14);

p2p.SetDeviceAttribute ("DataRate", StringValue ("50Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("50ms"));
NetDeviceContainer nd43 = p2p.Install (n43);

p2p.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("5ms"));
NetDeviceContainer nd30 = p2p.Install (n30);

p2p.SetDeviceAttribute ("DataRate", StringValue ("1Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("1ms"));
NetDeviceContainer nd02 = p2p.Install (n02);

p2p.SetDeviceAttribute ("DataRate", StringValue ("2Mbps"));
p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
NetDeviceContainer nd23 = p2p.Install (n23);

// Later, we add IP addresses.
NS_LOG_INFO ("Assign IP Addresses.");
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer i01 = ipv4.Assign (nd01);

ipv4.SetBase ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer i14 = ipv4.Assign (nd14);

ipv4.SetBase ("10.1.3.0", "255.255.255.0");
Ipv4InterfaceContainer i43 = ipv4.Assign (nd43);

ipv4.SetBase ("10.1.4.0", "255.255.255.0");
Ipv4InterfaceContainer i30 = ipv4.Assign (nd30);

ipv4.SetBase ("10.1.5.0", "255.255.255.0");
Ipv4InterfaceContainer i02 = ipv4.Assign (nd02);

ipv4.SetBase ("10.1.6.0", "255.255.255.0");
Ipv4InterfaceContainer i23 = ipv4.Assign (nd23);

// Create the OnOff application to send UDP datagrams of size
// 210 bytes at a rate of 448 Kb/s

NS_LOG_INFO ("Create Applications.");
uint16_t port = 8000; // Discard port (RFC 863)

OnOffHelper onoff1 ("ns3::UdpSocketFactory",
InetSocketAddress (i02.GetAddress (1), port));
onoff1.SetConstantRate (DataRate ("448kb/s"));

ApplicationContainer onOffApp1 = onoff1.Install (c.Get (1));
onOffApp1.Start (Seconds (10.0));
onOffApp1.Stop (Seconds (20.0));

// Create packet sinks to receive these packets
PacketSinkHelper sink ("ns3::UdpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny (), port));
NodeContainer sinks = NodeContainer (c.Get (2), c.Get (1));
ApplicationContainer sinkApps = sink.Install (sinks);
sinkApps.Start (Seconds (0.0));
sinkApps.Stop (Seconds (21.0));

AsciiTraceHelper ascii;
p2p.EnableAsciiAll (ascii.CreateFileStream ("lsr.tr"));
p2p.EnablePcapAll ("lsr");

AnimationInterface anim("lsr.xml");
anim.SetConstantPosition(c.Get(0),0.0,50.0);
anim.SetConstantPosition(c.Get(1),50.0,100.0);
anim.SetConstantPosition(c.Get(2),50.0,50.0);
anim.SetConstantPosition(c.Get(3),50.0,0.0);
anim.SetConstantPosition(c.Get(4),100.0,50.0);

Simulator::Stop (Seconds (30));
NS_LOG_INFO ("Run Simulation.");
Simulator::Run ();
Simulator::Destroy ();
NS_LOG_INFO ("Done.");

return 0;
}

How to Run this file in ns3

This file LinkStateRouting.cc have to be stored in ns-3.29/scratch folder

open a terminal

$ cd ns-allinone-3.29/ns-3.29/

$ ./waf --run scratch/LinkStaterouting

To run network animation

Open a new terminal

$] cd ns-allinone-3.29/netanim-3.108/

$] ./NetAnim

The output is shown like this

Link State Routing

Tracemetrics

Open a new Terminal

$] cd tracemetrics-1.4.0/

$] java -jar tracemetrics.jar

TCP Congestion Control using NS2

2021-03-08T21:47:00.000+05:30

Congestion control is one of the performance metrics of TCP protocol. There are so many TCP Versions to control congestion in the network.
NS2 also supports various TCP protocols like TCP Vegas, TCP Reno, TCP, TCP Sack, Full TCP, TCP linux, etc.

The code can be downloaded from the following link

https://drive.google.com/file/d/1EGeJOtqapDIB5NQy5Ar1L7nzPIihSyck/view?usp=sharing

Each TCP protocols has different mechanism in controlling the congestion. Some are good at Congestion control, some are good at error ands flow control.

Before understanding the congestion control, one has to know the congestion window of TCP. TCP has a congestion window (cwnd_ in ns2), this variable affects or predicts the congestion control.

The value assigned to this variable will alter the congestion control. Here are the files that are of prime importance before dealing with congestion control.
~ns-2.35/tcp/tcp.cc
~ns-2.35/tcp/tcp.h
~ns-2.35/tcl/lib/ns-default.tcl (In this file, the constant values for all the protocols in ns2 are set)

For example, the packet size of CBR is 210 by default, this value is represented like this in the ns-default.tcl file.

Application/Traffic/CBR set packetSize_ 210

if you want to change the packet size of CBR for ns2, you may change the above line to

Application/Traffic/CBR set packetSize_ 500

which is set to 500 bytes, the above line will affect the entire tcl scripts (the value is changed to 500), instead the packet size can be changed within the TCL file where it is programmed as given below

set cbr [new Application/Traffic/CBR]
$cbr set packetSize_ 500
The above line will change the packet size for this file only. Similarly, the TCP congestion window is set like this
Agent/TCP set cwnd_ 0

the default value is 0 and you may modify this within the file as given below
set tcp [new Agent/TCP]
$tcp set cwnd_ 3

To know more about congestion control, please see the video given below for detailed instructions.

T S Pradeep Kumar

xgraph in Ubuntu 20.04 | Solved (Issues)

2021-01-16T16:56:00.001+05:30

XGRAPH in Ubuntu 20.04

xgraph - Standalone application in Ubuntu 20.04

There are two options to use either 32 bit or 64 bit OS, to find what OS instruction set your OS is Using, use the following command

$] uname -a

Linux pradeepkumar-Latitude-3410 5.8.0-36-generic #40~20.04.1-Ubuntu SMP Wed Jan 6 10:15:55 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux

In the above output x86_64 indicates its 64 bit, else it may show i686 which indicates its a 32 bit OS

You can watch the complete instruction here on how to do?

$] gedit ~/.bashrc
include the following line in the .bashrc file (Copy the PAT H of xgraph and paste it in .bashrc)

alias xgraph=/home/pradeepkumar/XGraph4.38_linux64/bin/xgraph

After the above change is made, restart the computer and its set.

$] xgraph

A window will be popping up as shown below

xgraph

How to plot a data file
#data.xg
1 3.2 4.3

2 4.5 6.9

3 9.8 11.9

4 10.2 17.6

5 7.8 22.2

To plot the above two curves, the following command can be used

$] xgraph data.xg

But only one curve will be printed, to print two curves use the following command

$] xgraph -c data.xg data.xg

You have selected to read column-oriented data in file 'data.xg'.

Please select the column numbers for x and y (first column = 1) ? 1 2

Using column 1 against 2.

You have selected to read column-oriented data in file 'data.xg'.

Please select the column numbers for x and y (first column = 1) ? 1 3

Using column 1 against 3.

10 points read.

Supply the values of two curves, 1 2 means X axis - 1 st column and Y axis - 2nd column

The output of the above command will be looking like this

xgraph

For more details you use https://www.xgraph.org/
I have used a 64 bit version, 32 bit version also available

Installing NS-3.32 in Ubuntu 20.04

2020-12-03T21:46:00.001+05:30

This is about installing ns version 3.32 in Ubuntu 20.04 LTS. #ns3 #ns3.32 #networksimulationThe commands used in the video are given here. $] sudo apt update $] sudo apt install build-essential autoconf automake libxmu-dev python3-pygraphviz cvs mercurial bzr git cmake p7zip-full python3-matplotlib python-tk python3-dev qt5-qmake qt5-default gnuplot-x11 wireshark Download the ns-allinone-3.32.tar.bz2 package from nsnam.org and copy it to /home/ folder

See the full video for detailed instructions

Extract it either in GUI or using command $] tar jxvf ns-allinone-3.32.tar.bz2 $] cd ns-allinone-3.32/ $] ./build.py --enable-examples --enable-tests The above command will take some time to install all the packages

You can see the output as shown below

ns3

To check whether ns3 installed successfully, use the following commands. $] cd ns-3.32/ $] ./waf --run hello-simulator You should get the output as Hello Simulator

$] ./waf --run first This is the example from the ns-3.32/examples/tutorial/first.cc file which will run directly using the above command But python files have to be moved to scratch folder. Use the following command to move it to scratch folder $] cp examples/tutorial/second.py scratch/ $] ./waf --pyrun scratch/second.py

The following figure shows the actual output.

How to execute python file in ns3

Thats all

Flying Adhoc Network Simulation (FANET) using NS3

2020-11-18T18:07:00.001+05:30

In this post, we will see how to simulation a Flying Adhoc Network (FANET) simulation using NS3.

Its actually MANET with 3D mobility Model called Gauss Markov Mobility Model.

See the following video for more details and explanation:

So all the nodes are flying in a 3D Fashion with X axis, Y Axis and Z Axis

The default values of the three axes are

X axis can be (-100m, 100m)

Y axis can be (-100m, 100m)

Z axis can be (0m, 100m)

We will take the following example for experimenting the Flying Adhoc Networks. To begin with, We use the following parameters for Simulation:

The name of the File is fanetex.cc

#include "ns3/point-to-point-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include <fstream>
#include <string>
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h"
#include "ns3/wifi-module.h"

#include "ns3/aodv-helper.h"
#include "ns3/internet-module.h"
#include "ns3/netanim-module.h"

using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("Mob");

int main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
 
  NodeContainer c;
  c.Create (20); //20 wireless nodes

 WifiHelper wifi;
wifi.SetStandard (WIFI_PHY_STANDARD_80211b);
//80211a, 80211b, 80211n, 2.4g and 5G, 80211ac, 80211ax is also supported.80211p (VANETs, WAVE)

  WifiMacHelper mac;
  mac.SetType ("ns3::AdhocWifiMac");
  //AdhocWifiMac, StaWifiMac, ApWifiMac
  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
                                "DataMode", StringValue ("OfdmRate54Mbps"));
  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
  wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
  wifiPhy.SetChannel (wifiChannel.Create ());
  NetDeviceContainer cDevices = wifi.Install (wifiPhy, mac, c);
 //
  NS_LOG_INFO ("Enabling AODV routing on all backbone nodes");
  AodvHelper aodv;
  //AODV protocol is being using FANETs.
  InternetStackHelper internet;
  internet.SetRoutingHelper (aodv); // has effect on the next Install ()
  internet.Install (c);

  //
  // Assign IPv4 addresses to the device drivers (actually to the associated
  // IPv4 interfaces) we just created.
  //
  Ipv4AddressHelper ipAddrs;
  ipAddrs.SetBase ("192.168.0.0", "255.255.255.0");
  Ipv4InterfaceContainer cInterfaces;
  cInterfaces=ipAddrs.Assign (cDevices);
  
 /*
//Mobility Model - 2D
MobilityHelper mobility;

mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
  "MinX", DoubleValue (0.0),
  "MinY", DoubleValue (0.0),
  "DeltaX", DoubleValue (5.0),
  "DeltaY", DoubleValue (10.0),
  "GridWidth", UintegerValue (3),
  "LayoutType", StringValue ("RowFirst"));

mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",  "Bounds", RectangleValue (Rectangle (-100, 100, -100, 100)));
mobility.Install (c);
 */
 
 //Mobility Model -3D
 MobilityHelper mobility;
mobility.SetMobilityModel ("ns3::GaussMarkovMobilityModel",
  "Bounds", BoxValue (Box (0, 100, 0, 100, 0, 100)),
  "TimeStep", TimeValue (Seconds (0.5)),
  "Alpha", DoubleValue (0.85),
  "MeanVelocity", StringValue ("ns3::UniformRandomVariable[Min=800|Max=1200]"),
  "MeanDirection", StringValue ("ns3::UniformRandomVariable[Min=0|Max=6.283185307]"),
  "MeanPitch", StringValue ("ns3::UniformRandomVariable[Min=0.05|Max=0.05]"),
  "NormalVelocity", StringValue ("ns3::NormalRandomVariable[Mean=0.0|Variance=0.0|Bound=0.0]"),
  "NormalDirection", StringValue ("ns3::NormalRandomVariable[Mean=0.0|Variance=0.2|Bound=0.4]"),
  "NormalPitch", StringValue ("ns3::NormalRandomVariable[Mean=0.0|Variance=0.02|Bound=0.04]"));
mobility.SetPositionAllocator ("ns3::RandomBoxPositionAllocator",
  "X", StringValue ("ns3::UniformRandomVariable[Min=0|Max=100]"),
  "Y", StringValue ("ns3::UniformRandomVariable[Min=0|Max=100]"),
  "Z", StringValue ("ns3::UniformRandomVariable[Min=0|Max=100]"));
mobility.Install (c);

 UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (c.Get(0));
  serverApps.Start (Seconds (1.0));
  serverApps.Stop (Seconds (10.0));

 UdpEchoClientHelper echoClient (cInterfaces.GetAddress(0), 9);
  echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
  echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps = echoClient.Install (c.Get(1));
  clientApps.Start (Seconds (2.0));
  clientApps.Stop (Seconds (10.0));

wifiPhy.EnablePcapAll ("Fanet3D"); //Packet Capture.
//Network Animation using NetAnim.
AnimationInterface anim("Fanet3D.xml");
//Ascii Trace Metrics can be processed using Tracemetrics Software.
AsciiTraceHelper ascii;
wifiPhy.EnableAsciiAll(ascii.CreateFileStream("Fanet3D.tr"));

  Simulator::Stop (Seconds (10.0));
  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}

The source code above explains the Flying Adhoc Networks in 3D using the Gauss Markov model. The RED code indicates its a 2D model and the BLUE code indicates the 3D mobility model.

How to run this file:

Step 1: Copy the above file in the folder ~ns-3.31/scratch

Step 2: Open the terminal

$] cd ns-allinone-3.31/ns-3.31/

$] ./waf --run scratch/fanetex

To See the animation:

$] ../netanim-3.108/NetAnim

and do as per the instructions in the video

NetAnim

Installing NS-3.31 in Ubuntu 20.04

2020-11-16T15:23:00.002+05:30

Installing ns-3.31 in Ubuntu 20.04 - 64 bit OS.

Follow the full video for more details:

Fresh installation of Ubuntu OS

$] sudo apt update

$] sudo apt install build-essential autoconf automake libxmu-dev

$] sudo apt install build-essential autoconf automake libxmu-dev python-pygraphviz cvs mercurial bzr git cmake p7zip-full python-matplotlib python-tk python-dev python-kiwi python-gnome2 python-gnome2-desktop qt4-dev-tools qt4-qmake qt4-qmake qt4-default gnuplot-x11 wireshark

extract to /home/pradeepkumar

$] echo $HOME

$] cd ns-allinone-3.31/

$] ./build.py --enable-examples --enable-tests

you will get the following screen after the installation

$] cd ns-allinone-3.31/ns-3.31/

$] ./waf --run hello-simulator

This will display

"Hello Simulator"

Which indicates that ns3 is installed successfully.

$] ./waf --run first

Software Defined Networking Architecture (SDN)

2020-11-10T11:14:00.001+05:30

Software Define Networking (SDN) from Dr. Pradeep Kumar TS, PhD

Ant Colony algorithm using NS2

2020-09-15T21:13:00.000+05:30

Ant Colony Algorithm in NS2 for Wired Networks.

Please follow the video for full instructions

I am running in Ubuntu 20.04

There are multiple files in Ant Colony (we use a protocol called Antnet) which i have already included in my blog called

https://www.nsnam.com

Lets go to my Blog. And Search for Ant Colony and Download the complete folder AntNet as shown in the video.

Now Copy paste the files in their corresponding location:

My Location if ns2 is

/home/pradeepkumar/ns-allinone-2.35/ns-2.35/

Inside this folder, the files have to be pasted in differnet sub folders...

Let me show you one by one...

cmu-trace.cc and cmu-trace.h have to be pasted to ~trace/

drop-tail.cc and drop-tail.h ---- ~queue/

Makefile.in to be replaced in the ns-2.35/ folder.

ns-default.tcl, ns-lib.tcl and ns-packet.tcl to be pasted at

~tcl/lib

packet.h to be replaced at common/ folder.

priqueue.cc and priqueue.h to be pasted at queue/

antnet/ folder have to be copied to ns-2.35/ folder (this is very important as this is the main algorithm.)

Step 2:

Change the GCC and G++ compiler in the Makefile.in as this is very important, else you might get errors if you leave the default GCC.

Please refer my following video on how to install ns2.35 in ubuntu 20.04.

Open Makefile.in

Change the following lines as given below

CC = gcc-4.8

CPP = g++-4.8

Step 3: Now Compile it

Open a Terminal.

$] cd ns-allinone-2.35/ns-2.35/

$] ./configure

$] make clean

$] make

This might take some time based on the speed of your computer.

Without errors, successfully installed....

Step 4:

Now lets understand the algorithm and packet structure.

Step 5:

Running the TCL File.

$] ns simpleant.tcl

We got three files simple.tr and simple.nam and rtable.txt

https://www.nsnam.com/2014/11/app-tool-for-analysing-tracefiles-for.html?q=ant+colony

Use of APP Tool Master.

URLs

Ant Colony Algorithm

https://www.nsnam.com/2015/03/ant-colony-algorithm-antnet-in-ns-235.html

APP Tools to analyse trace files.

https://www.nsnam.com/2014/11/app-tool-for-analysing-tracefiles-for.html

To download the Ant colony algorithm

https://drive.google.com/drive/folders/0B4nUSbTYSK4TflVJRDVXQ1QzTUo0bUJWUlAyZkx4UFdzQzJhYkpvWXU5N0k4QlE5Yl9tOFE

Thanks for watching my video...

Complete NS2 Tutorial

2020-08-29T14:55:00.002+05:30

Complete NS2 Tutorial

To benefit the various students and research scholars who are working in NS2 (Network Simulator 2), this NS2 Tutorial will help you in understanding the basics of NS2 and you can accomplish most of the your simulation using this software.

Total Duration of the Videos: 11 Hours

Total Lectures - 25 (More will be added to the following list)

To view the Lectures, Click here to go the Playlist in my Youtube Channel.

https://www.youtube.com/watch?v=k_lfL93zDNQ&list=PLX6MKaDw0naZBi0R-6_IAuYA9Yk_yuyXp

How to enable Course Outcomes in Moodle | Moodle 3.9

2020-07-19T21:12:00.002+05:30

#Moodle #ELearning #PradeepKumarTS This post is to enable Course outcomes or Learning Outcomes in Moodle Learning Management Systems. This is for Faculty Members or one who teach a course. Steps: 1. Login to Moodle with your username and Password.

2. Go to Your Course -- Click the Settings ICON -- Click "Outcomes" and select the outcomes of your course. (there will be all course outcomes, select the three or four outcomes of your course and Click Add button so that the Outcomes will be copied from Right to Left )

3. Once done, give any activities to the students -- you can see a outcome menu and select the corresponding outcome(s) that the student or learner can attain by doing that activity. 4. During evaluation, You can evaluate the outcomes as well (There will be rubrics like Excellent, Very Good, Good, Average and Fair). The Administrator can customise the above Rubrics according to their convenience. Excellent - 5 point and Fair is 1 point. 5. During the end semester, the grade report can be downloaded with outcomes as well as indicated in the Video.

How to read a CSV file in R | Lecture 4

2020-06-22T23:38:00.003+05:30

How to read a CSV file in R

CSV is called as Comma Separated Value file which can be easily generated using any spreadsheet application like OpenOffice, LibreOffice, MS Office, etc...

We can also create csv files using any text editor as well as given below.

Create a csv file as per the format given below:

Name, Age, Science, Maths, Social

Kumar,14,57,67,78

Anand,24,98,97,90

Balakumar, 25,35,45,56

To read this file

> mydata=read.csv("users.csv");

> mydata

name age science maths social

1 kumar 14 57 67 78

2 Anand 24 98 97 90

3 Balakumar 25 35 45 56

To create a new file,

df <- data.frame(name = c("Jon", "Bill", "Maria"), age = c(23, 41, 32), science=c(20,30,40), maths=c(56,67,78), social=c(98,76,65))

write.csv(df,"anewfile.csv", row.names = FALSE)

Arrays and Matrices in R | Lecture 3

2020-06-22T21:27:00.000+05:30

Arrays and Matrices in R

Arrays are declared in R using the dim() or array() functions.

For example:

> mycarsale.array<-1:30

> mycarsale.array

[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

[17] 17 18 19 20 21 22 23 24 25 26 27 28 29 30

The above command allocates a vector of 1 to 30 to the variable array called mycarsale.array

To make it as a matrix, we can use dim() function as given below

> dim(mycarsale.array)<-c(3,5,2)

> mycarsale.array

, , 1

[,1] [,2] [,3] [,4] [,5]

[1,] 1 4 7 10 13

[2,] 2 5 8 11 14

[3,] 3 6 9 12 15

, , 2

[,1] [,2] [,3] [,4] [,5]

[1,] 16 19 22 25 28

[2,] 17 20 23 26 29

[3,] 18 21 24 27 30

In the above output 3 indicates the number of columns, 5 indicate the number of columns and 2 indicates the number of tables.

Array in R

> mycarsale.array[2,3,1]

[1] 8

> mycarsale.array[2,3,2]

[1] 23

How to Use R as a Calculator | Lecture 2

2020-06-22T21:12:00.000+05:30

R as a Calculator

How to use R as a calculator

Open R Studio either through GUI or through Command/Terminal Mode by typing

$] rstudio

In the Console Window, type the following

> 2+3

> log(10)

>log10(10)

> 3^2+4^3

> exp(5)

> exp(1)

Check the output given in the following Window.

To clear the console Window, use the Shortcut key Ctl+L,

in R, pi is recognised as PI = 3.141

>pi

[1] 3.141593

We can use -ve sign also in front of the numbers

> -9 + 1

[1] -8

Basics of R | Lecture 1

2020-06-22T16:11:00.003+05:30

Basics of R

Its a software and programming language used for statistical computing and report generation.

Its Free and open source with GPL Licensing

It has a GUI to work upon called as RStudio.

This software can be installed using the following command in Ubuntu

$] sudo apt update

$] sudo apt install build-essential autoconf automake libxmu-dev

$] sudo apt install r-base rstudio

To open the software, you can use either through the GUI or through terminal using

$] rstudio

The GUI looks like this

R Studio

Features of R

Its based on object oriented design
R Commands can be included or embedded with other software or applications or programming languages namely C++. Java and other commercial tools.
It supports multiple Operating systems like Windows, Linux, Mac OS, etc.

Advantages of R

Good community to help
Works in a interactive way
Plotting and graphs are easy to plot using the libraries.
New libraries can be easily generated.
Its completely modular and object oriented.

See the following screenshot that shows the RStudio Window. We can run the commands in Console window and get the output interactively.

We can write a script directly in the Script window and execute the program using Run Button and other two window namely environment and file window.

R Studio

Disadvantages

R needs more memory, so large datasets can be processed with the maximum available memory in the machine.