Simulation is the process of learning by doing. Whenever there is something new in the world, we try to analyse it first by examining it and in the process get to learn a lot of things. This entire course is called as Simulation. Correlating to this process, in order to understand all the complexities one need to model the entire role-play in form of computer simulation, the need is to build artificial objects and assign them roles dynamically. Computer simulation is the designing of a theoretical physical system on a digital computer with emphasis on model designing, execution and analysis. After creation of the mathematical model the most important step is to create a computer program for updating the state and event variables through time (by time slicing or event scheduling). If this simulation is carried out successively in parallel computers, it is called Parallel or Distributed simulation. Network simulation (NS) is one of the types of simulation, which is used to simulate the networks such as in MANETs, VANETs etc. It provides simulation for routing and multicast protocols for both wired and wireless networks. NS is licensed for use under version 2 of the GNU (General Public License) and is popularly known as NS2. It is an object-oriented, discrete event-driven simulator written in C++ and Otcl/tcl. NS-2 can be used to implement network protocols such as TCP and UPD, traffic source behavior such as FTP, Telnet, Web, CBR and VBR, router queue management mechanism such as Drop Tail, RED and CBQ, routing algorithms and many more. In ns2, C++ is used for detailed protocol implementation and Otcl is used for the setup. The compiled C++ objects are made available to the Otcl interpreter and in this way, the ready-made C++ objects can be controlled from the OTcl level.

Install NS-2 using this command

sudo apt-get install ns2

Nam is also needed to install. Nam (Network Animator) is an animation tool to graphically represent the network and packet traces. Use this comman

sudo apt-get install nam

Some basic Otcl script syntax

Basic Command

filter_none

brightness_4

seta 8

setb [expr $a/8]

Explanation : In the first line, the variable a is assigned the value 8. In the second line, the result of the command [expr $a/8], which equals 1, is then used as an argument to another command, which in turn assigns a value to the variable b. The “$” sign is used to obtain a value contained in a variable and square brackets are an indication of a command substitution. Define new procedures with proc command

filter_none

brightness_4

proc factorial fact {

if {$fact <= 1} {

return 1

}

expr $fact * [factorial [expr $fact-1]]

{

To open a file for reading

filter_none

brightness_4

set testfile [open hello.dat r]

Similarly, put command is used to write data into the file

filter_none

brightness_4

set testfile [open hello.dat w]

puts $testfile “hello”

To call subprocesses within another process, exec is used, which creates a subprocess and waits for it to complete

filter_none

brightness_4

exec rm $testfile

To be able to run a simulation scenario, a network topology must first be created. In ns2, the topology consists of a collection of nodes and links

filter_none

brightness_4

set ns [new Simulator]

The simulator object has member functions which enables to create the nodes and define the links between them. The class simulator contains all the basic functions. Since ns was defined to handle the Simulator object, the command $ns is used for using the functions belonging to the simulator class.In the network topology nodes can be added in the following manner

filter_none

brightness_4

set n0 [$ns node]

set n1 [$ns node]

Traffic agents (TCP, UDP etc.) and traffic sources (FTP, CBR etc.) must be set up if the node is not a router. It enables to create CBR traffic source using UDP as transport protocol or an FTP traffic source using TCP as a transport protocol.CBR traffic source using UDP

filter_none

brightness_4

set udp0 [new Agent/UDP]

$ns attach-agent $n0 $udp0

set cbr0 [new Application/Traffic/CBR]

$cbr0 attach-agent $udp0

$cbr0 set packet_size_ 512

FTP traffic source using TCP

filter_none

brightness_4

set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0

set ftp0 [new Application/FTP]

$ftp0 attach-agent $tcp0

$tcp0 set packet_size_ 512

Below is the implementation of creating links between the source and destination using both ftp and tcp

filter_none

brightness_4

Create a simulator object

set ns [new Simulator]

# Define different colors

# for data flows (for NAM)

$ns color 1 Blue

$ns color 2 Red

# Open the NAM trace file

set nf [open out.nam w]

$ns namtrace-all $nf

# Define a ‘finish’ procedure

proc finish {}

{

global ns nf

$ns flush-trace

# Close the NAM trace file

close $nf

# Execute NAM on the trace file

exec nam out.nam &

exit 0

}

# Create four nodes

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

# Create links between the nodes

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

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

$ns duplex-link $n2 $n3 1.7Mb 20ms DropTail

# Set Queue Size of link (n2-n3) to 10

$ns queue-limit $n2 $n3 10

# Give node position (for NAM)

$ns duplex-link-op $n0 $n2 orient right-down

$ns duplex-link-op $n1 $n2 orient right-up

$ns duplex-link-op $n2 $n3 orient right

# Monitor the queue for link (n2-n3). (for NAM)

$ns duplex-link-op $n2 $n3 queuePos 0.5

# Setup a TCP connection

set tcp [new Agent/TCP]

$tcp set class_ 2

$ns attach-agent $n0 $tcp

set sink [new Agent/TCPSink]

$ns attach-agent $n3 $sink

$ns connect $tcp $sink

$tcp set fid_ 1

# Setup a FTP over TCP connection

set ftp [new Application/FTP]

$ftp attach-agent $tcp

$ftp set type_ FTP

# Setup a UDP connection

set udp [new Agent/UDP]

$ns attach-agent $n1 $udp

set null [new Agent/Null]

$ns attach-agent $n3 $null

$ns connect $udp $null

$udp set fid_ 2

# Setup a CBR over UDP connection

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set type_ CBR

$cbr set packet_size_ 1000

$cbr set rate_ 1mb

$cbr set random_ false

# Schedule events for the CBR and FTP agents

$ns at 0.1 “$cbr start”

$ns at 1.0 “$ftp start”

$ns at 4.0 “$ftp stop”

$ns at 4.5 “$cbr stop”

# Detach tcp and sink agents

# (not really necessary)

$ns at 4.5 “$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink”

# Call the finish procedure after

# ۵ seconds of simulation time

$ns at 5.0 “finish”

# Print CBR packet size and interval

puts “CBR packet size = [$cbr set packet_size_]”

puts “CBR interval = [$cbr set interval_]”

# Run the simulation

$ns run

ns-1

The first version of ns, known as ns-1, was developed at Lawrence Berkeley National Laboratory (LBNL) in the 1995-97 timeframe by Steve McCanne, Sally Floyd, Kevin Fall, and other contributors. This was known as the LBNL Network Simulator, and derived in 1989 from an earlier simulator known as REAL by S. Keshav.

ns-2

Ns-2 began as a revision of ns-1. From 1997-2000, ns development was supported by DARPA through the VINT project at LBL, Xerox PARC, UCB, and USC/ISI. In 2000, ns-2 development was supported through DARPA with SAMAN and through NSF with CONSER, both at USC/ISI, in collaboration with other researchers including ACIRI. Ns-2 incorporates substantial contributions from third parties, including wireless code from the UCB Daedelus and CMU Monarch projects and Sun Microsystems.

ns-3

In 2006, a team led by Tom Henderson, George Riley, Sally Floyd, and Sumit Roy, applied for and received funding from the U.S. National Science Foundation (NSF) to build a replacement for ns-2, called ns-3. This team collaborated with the Planete project of INRIA at Sophia Antipolis, with Mathieu Lacage as the software lead, and formed a new open source project. In the process of developing ns-3, it was decided to completely abandon backward-compatibility with ns-2. The new simulator would be written from scratch, using the C++ programming language. Development of ns-3 began in July 2006.

Current status of the three versions is

• ns-1 development stopped when ns-2 was founded. It is no longer developed nor maintained.

• ns-2 development stopped around 2010. It is no longer developed nor maintained.

• ns-3 is actively being developed and maintained.

ns-4

NS-4 is the name of a P4 driven network simulator developed by Tsinghua University, China. NS4 is divided into control plane half and data plane half, which collectively simulate a complete network system with programmable data plane (PDP). Developers simulate a controller by instantiating a ‘Controller Model‘ and simulate a P4 device by instantiating a ‘Programmable Data Plane Model‘. Traditional devices like router or switch are also supported in NS4 but omitted in the figure

Workflow

The procedures to simulate a P4-enabled network are ٫ configure the behavior of data plane by inputting a compiled P4 program to the P4 pipeline configurator; 2. create control plane and populate table entries to P4 devices, by either implementing a controller application inside the controller model or simply running an arbitrary controller application (such as ONOS) outside NS4; 3. add ports (maybe connected to various channels) to the PDP model. 4. At this point, we have this PDP model configured and functional as a P4 device. Next steps are building network topology, installing applications at terminal nodes and triggering the simulator.

NS4 can define the behavior of your network element just by inputting a P4 file. When simulating there is no need to learn the network simulator libraries and implement device behavior using network simulator’s library anymore. It thus solves all the complications of ns-2 and ns-3.

Design

ns-3 is built using C++ and Python with scripting capability. The ns library is wrapped by Python thanks to the pybindgen library which delegates the parsing of the ns C++ headers to castxml and pygccxml to automatically generate the corresponding C++ binding glue. These automatically-generated C++ files are finally compiled into the ns Python module to allow users to interact with the C++ ns models and core through Python scripts. The ns simulator features an integrated attribute-based system to manage default and per-instance values for simulation parameters.

Simulation workflow

The general process of creating a simulation can be divided into several steps

Topology definition: To ease the creation of basic facilities and define their interrelationships, ns-3 has a system of containers and helpers that facilitates this process

Model development: Models are added to simulation (for example, UDP, IPv4, point-to-point devices and links, applications); most of the time this is done using helpers

Node and link configuration: models set their default values (for example, the size of packets sent by an application or MTU of a point-to-point link); most of the time this is done using the attribute system

Execution: Simulation facilities generate events, data requested by the user is logged Performance analysis: After the simulation is finished and data is available as a time-stamped event trace. This data can then be statistically analysed with tools like R to draw conclusions. Graphical Visualization: Raw or processed data collected in a simulation can be grap