The Role of NCTUns for fixed network Communication Engineering

Nargis Begam
Teaching Assistant
Department of Electronics and Electrical Engineering
Eastern University
R # 4, Dhanmondi, Dhaka-1207
Cell: 01720424278
takiadnan@yahoo.com

Abstract

NCTUns is a simulation tool which is very significant for communication engineering. It is

a real-life application program by which we can study of network behaviors and
performance analysis. It is a method that can be used to describe or predict how a system
will operate given certain choices for the controllable inputs and randomly generated
values for the probabilistic inputs. In this paper has been provided NCTUns for fixed
network and its performance curves which are very important in communication
engineering.

1. Introduction

This network simulator is an open source that enables to modify modules codes of
software for communication engineering. This software has a well developed graphical
user interface. Here, external host (e.g., hubs or switches) has been used for data
transmission. In this case real external data flows are obtainable, which are directed to
various types of networks in communication engineering. Regarding to simulation results
conclusions has been made.
NCTUns is developed by National ChiaoTung University. NCTUns simulates the
hardware characteristics of network devices, the protocol stacks employed in these devices
(e.g., the bridge learning protocol used in a switch), and the implementation of application
programs on these devices. This tool provides network utility programs for communication
engineering to make digital or hard copies for personal or classroom. These topologies
specify network parameters, monitoring traffic flows, gathering statistics about a simulated
network, etc.
Simulation is one of the most commonly used quantitative approaches to decision making.
It is a method for learning about a real system by experimenting with a model that
represents the system. The simulation model contains the mathematical expressions and
logical relationships that describe how to compute the value of the outputs given the values
of the inputs. Any simulation model has two inputs: controllable inputs and probabilistic
inputs.
Simulation is not an optimization technique. It is a method that can be used to describe or
predict how a system will operate given certain choices for the controllable inputs and
randomly generated values for the probabilistic inputs.
NCTUns is a technique where a program simulates the behavior of a network. The
program performs this simulation either by calculating the interaction between the different
virtual network entities (hosts/routers, data links, packets, etc) using mathematical
formulas, or actually capturing and playing back network parameters from a real
production network. Using this input, the behavior of the network and the various
applications and services it supports can be observed in a test lab. Various attributes of the
environment can also be modified in a controlled manner to asses these behaviors under
different conditions. When a simulation program is used in conjunction with live
applications and services in order to observe end-to-end performance to the user desktop,
this technique is also referred to as network emulation. Network simulators are used to
predict the behavior of networks and applications under different situations. Researchers
use network simulators to see how their protocols would behave if deployed. It is typical to
use a network simulator to test routing protocols, MAC (Medium Access Control)
protocols, transport protocols, applications etc. Companies use simulators to design their
networks or applications to get a feel for how they will perform under current or projected
real-world conditions.

2. Capabilities and Features of NCTUns

The NCTUns is a high-fidelity and extensible network simulator and emulator capable of
simulating various protocols used in both wired and wireless IP networks. Its core
technology is based on the novel kernel re-entering methodology invented by Prof. S.Y.
Wang when he was pursuing his Ph.D. degree at Harvard University. Due to this novel
methodology, NCTUns provides many unique advantages that cannot be easily achieved
by traditional network [3]. In the following, we briefly explain its capabilities and features.

It directly uses the real-life Linuxs TCP/IP protocol stack to generate recording method
simulation results. By using a novel kernel re-entering simulation methodology, a real-life
UNIX (e.g., Linux) kernels protocol stack can be directly used to generate high-fidelity
simulation results.

It can use any real-life presented or to-be-developed UNIX application program as a traffic
generator program without any adjustment. Any real-life program can be run on a
simulated network to generate network traffic. This enables a researcher to test the
functionality and performance of a distributed application or system under various network
conditions. Another important advantage of this feature is that application programs
developed during simulation studies can be directly moved to and used on real-world
UNIX machines after simulation studies are finished. This eliminates the time and effort
required to port a simulation prototype to a real-world implementation if traditional
network simulators are used.

It can use any real-life UNIX network configuration and monitoring tools. For example,
the UNIX route, ifconfig, netstat, tcpdump, traceroute commands can be run on a
simulated network to configure or monitor the simulated network.

Its setup and procedure of a simulated network and application programs are exactly the
same as those used in real-world IP networks. For example, each layer-3 interface has an
IP address assigned to it and application programs directly use these IP addresses to
communicate with each other. For this reason, any person who is familiar with real-world
IP networks can easily learn and operate NCTUns in a few minutes. For the same reason,
NCTUns can be used as an educational tool to teach students how to configure and operate
a real-world network.
It simulates many special and new types of networks. The supported types include
Ethernet-based fixed Internet, IEEE 802.11(b) wireless LANs, mobile ad hoc (sensor)
networks, GPRS cellular networks, optical networks (including both circuit-switching and
busrt-switching networks), IEEE 802.11(b) dual-radio wireless mesh networks, IEEE
802.11(e) QoS wireless LANs, Planned and active mobile ad hoc networks, and 3dB beam
width 60-degree and 90-degree directional antennas.

It simulates different networking devices. For example, Ethernet hubs, switches, routers,
hosts, IEEE 802.11(b) wireless stations and access points, WAN (for purposely
delaying/dropping/reordering packets), obstacle (block/attenuate wireless signal, block
mobile nodes movement, block mobile nodes views), GPRS base station, GPRS phone,
GPRS GGSN, GPRS SGSN, optical circuit switch, optical burst switch and boundary
routers, IEEE 802.11(b) dual-radio wireless mesh access point, IEEE 802.11(e) QoS access
points and mobile stations, etc.

It can be used as an emulator. An external host in the real world can exchange packets
(e.g., set up a TCP connection) with nodes (e.g., host, router, or mobile station) in a
network simulated by NCTUns. Two external hosts in the real world can also replace their
packets via a network simulated by NCTUns. This feature is very useful as the function
and performance of real-world devices can be experienced under various simulated
network conditions.

It simulates different protocols. For example, IEEE 802.3 CSMA/CD MAC, IEEE 802.11
(b) CSMA/CA MAC, IEEE 802.11(e) QoS MAC, IEEE 802.11(b) wireless mesh network
routing protocol, learning bridge protocol, spanning tree protocol, IP, Mobile IP, RIP,
OSPF, UDP, TCP, RTP/RTCP/SDP, HTTP, FTP, Telnet, etc.

It simulates a network swiftly. By combining the kernel re-entering methodology with the
discrete-event simulation methodology, a simulation job can be finished quickly.

If the user fixes the random number seed for a simulation case, the simulation results of a
case are the same across different simulation runs even if there are some other behavior
(e.g., disk I/O) occurring on the simulation machine. It generates repeatable simulation
results.

It provides a highly-integrated and specialized GUI environment. This GUI can help a user
(1) sketch network topologies, (2) construct the protocol modules used inside a node, (3)
specify the moving paths of mobile nodes, (4) plot network performance graphs, (5)
playing back the animation of a logged packet transfer trace, etc. All these operations can
be easily and spontaneously done with the GUI.
Its simulation engine adopts open-system architecture and is open source. By using a set of
module APIs provided by the simulation engine, a protocol developer can easily
implement his (her) protocol and integrate it into the simulation engine. NCTUns uses a
simple but effective syntax to describe the settings and configurations of a simulation job.
These descriptions are generated by the GUI and stored in a suite of files. Normally the
GUI will automatically transfer these files to the simulation engine for execution.
However, if a researcher wants to try his (her) novel device or network configurations that
the current GUI does not support, he (she) can totally avoid the GUI and generate the suite
of report files by himself (herself) using any text editor (or script program). The non-GUI-
generated suite of files can then be manually fed to the simulation engine for execution.

It supports remote and concurrent simulations. NCTUns adopts a distributed architecture.

The GUI and simulation engine are separately implemented and use the client-server
model to communicate. Therefore, a remote user using the GUI program can remotely
submit his (her) simulation job to a server running the simulation engine. The server will
run the submitted simulation job and later return the results back to the remote GUI
program for analyses. This scheme can easily support the cluster computing model in
which multiple simulation jobs are performed in parallel on different server machines. This
can increase the total simulation throughput.

3. Mechanism and Design of NCTUns

NCTUns adopts a distributed architecture. For understanding the mechanism and design of
NCTUns, need to discuss many things. Here, briefly discuss the following components
which are helping to accepting the method and propose of NCTUns.

The first component is the GUI program by which a user edits a network topology,
configures the protocol modules used inside a network node, specifies mobile nodes initial
location and moving paths, plots performance graphs, plays back the animation of a packet
transfer trace, etc.

Fig 3. The Mechanism of NCTUns

The second component is the simulation engine program, which provides basic and useful
simulation services (e.g. event scheduling, timer organization, and packet manipulation,
etc.) to protocol modules. We call a machine on which a simulation engine program resides
a simulation server.
The third component is the set of various protocol modules, each of which implements a
specific protocol or function (e.g., packet scheduling or buffer management). All protocol
modules are C++ classes and are compiled and linked with the simulation engine program.

The fourth component is the simulation job dispatcher program that can simultaneously
manage and use multiple simulation servers to increase the aggregate simulation
throughput. It can be run on a separate machine or on a simulation server.

The fifth component is the coordinator program. On every simulation server, the
coordinator program must be run up. The coordinator should be alive as long as the
simulation server is alive. When a simulation server is powered on and brought up, the
coordinator must be run up. It will register itself with the dispatcher to join in the
dispatchers simulation server farm. When the status (idle or busy) of the simulation server
changes, it will notify the dispatcher of the new status. This enables the dispatcher to
choose an available simulation server from its simulation server farm to service a job.

When the coordinator receives a job from the dispatcher, it forks a simulation engine
process to simulate the specified network and protocols. It may also fork several real-life
application program processes specified in the job. These processes are used to generate
traffic in the simulated network. When the simulation engine process is alive, the
coordinator communicates with the dispatcher and the GUI program on behalf of the
simulation engine process. For example, the simulation engine process needs to
periodically send its current simulation clock to the GUI program. This is done by first
sending the clock information to the coordinator and then asking the coordinator to
forward this information to the GUI program. This enables the GUI user to know the
progress of the simulation. During a simulation, the GUI user can also on-line set or get an
objects value (e.g., to query or set a switchs current switch table). Message exchanges
that occur between the simulation engine process and the GUI program are all relayed via
the coordinator.

The sixth component is the kernel patches that need to be made to the kernel source code
so that a simulation engine process can run on a UNIX machine correctly. Currently
NCTUns 5.0 runs on Red-Hats Fedora Core 9, whose kernel is Linux 2.6.25.

The seventh component is the various real-life user-level application programs. Due to the
novel kernel-reentering simulation methodology, any real-life existing or to-be developed
application program can be directly run up on a simulated network to generate realistic
network traffic.

The eighth component is the various user-level daemons that are run up for the whole
simulation case. For example, NCTUns provides RIP and OSPF routing daemons. By
running these daemons, the routing entries needed for a simulated network can be
constructed automatically. As another example, NCTUns provides and automatically runs
up several emulation daemons when it is turned into an emulator. Due to this distributed
design, a remote user can submit his (her) simulation job to a job dispatcher, and the
dispatcher will then forward the job to an available simulation server for execution. The
server will process (simulate) the job and later return the results back to the remote GUI
program for further analyses. This scheme can easily support the server farm model in
which multiple simulation jobs are performed concomitantly on different simulation
servers.
In addition to the above multi-machine mode, another mode called the single machine
mode is supported. In such a mode, all of these components are installed and run on a
single machine. Although in this mode different simulation jobs cannot be run concurrently
on different machines, since most users have only one machine to run their simulations,
this mode may be more appropriate for them. In fact, it is the default mode after the
NCTUns package is installed.
The performance of NCTUns was discussed detail in [11].Here, in this paper has been
provided some cases and its performance curves which is very important in communication
engineering.

4. Several Screen-shots of NCTUns

Some screenshots of NCTUns are given in the next page to give readers a quick idea about
NCTUns in several cases of communication engineering. In communication engineer we
can use both fixed wired network and mobile wireless network. In both cases NCTUns is
very important.

Here, in this paper is provided some very important design and its performance in next
page for fixed wired network.

All time when a client launches the GUI program, the next starting screen in the next page
will detonate up.

0
(a) (b)

Fig 4. (a). the opening screen of NCTUns. (b) The blow up the network
The topology editor provides a suitable and spontaneous way to graphically create a
network topology. This constructed network is a fixed wired network. For ITS
applications, a road network can also be constructed.

(a) (b)
Fig 4.2: The screen of topology editor.

A network tool (node) has many attributes. Setting and modifying the attributes of a
network node can be easily done by double-clicking the icon of a network node. A
characteristic dialog box can be explaining its characteristics.

(a) (b)

Fig 4.3: The screen of characteristic dialog box.

By using this packet moving picture, a packet transfer trace logged during a simulation can
be replayed at a particular speed. Both wired and wireless networks are supported. Here is
shown for wired network. This capability is very useful because it helps a researcher
visually see and sort out the performance of a network protocol. It is very useful for
educational purposes because students can see the behavior of a protocol.
 Fig 4.4: The packet animation player of NCTUns

This performance monitor can simply and graphically produce and present plots of some
monitored performance metrics over time. Because the format of its input data log file uses
the general two-column (x, y) format and the data is in plain text, the performance monitor
can be used as an independent plotting tool.

Fig: The performance monitor of NCTUns

5. CONCLUSIONS

In this paper we propose extensions to NCTUns network simulator to allow the consistent
emulation for fixed wired network. The approach used to achieve such a goal can also
benefit other emulation cases, allowing large emulations to be divided into smaller cases
running on interconnected hosts, each one running an instance of NCTUns. The important
study is to test and discover the best traffic classifications and bandwidth allocations for
different types of system or scenario using the routers and the performance monitor.
7. REFERENCES

[1] S.Y. Wang and H.T. Kung, A Simple Methodology for Constructing Extensible
and High-Fidelity TCP/IP Network Simulator, IEEE INFOCOM99, March 21-
25, 1999, New York, USA.
[2] S.Y. Wang and H.T. Kung, A New Methodology for Easily Constructing
Extensible and High-Fidelity TCP/IP Network Simulators, Computer Networks, Vol.
40, Issue 2, October 2002, pp. 257-278.
[3] S.Y. Wang, NCTUns 1.0, in the column Software Tools for Networking, IEEE
Networks, Vol. 17, No. 4, July 2003.
[4] S.Y. Wang, C.L. Chou, C.H. Huang, C.C. Hwang, Z.M.Yang, C.C. Chiou, and C.C.
Lin, The Design and Implementation of NCTUns 1.0 Network Simulator,
Computer Networks, Vol. 42, Issue 2, June 2003, pp. 175-197.
[5] S.Y. Wang and Y.B. Lin, NCTUns Network Simulation and Emulation for Wireless
Resource Management, Wireless Communication and Mobile Computing, Wiley, Vol.
Issue 8, pp. 899 ~ 916, December 2005.
[6] S.Y. Wang and K.C. Liao, Innovative Network Emulations using the NCTUns Tool,
as a book chapter of the Computer Networking and Networks book, (ISBN 1-
59454-830-7, published by Nova Science Publishers)
[7] S.Y. Wang, C.L. Chou, C.C. Lin, The Design and Implementation of the NCTUns
Network Simulation Engine, Elsevier Simulation Modeling Practice and Theory.