Term Project Report

Document Sample
Term Project Report Powered By Docstoc
					                        CPSC 689-606

 Special Topics in user Interfaces for Information Visualization



                      Term Project Report




Time Series Visualization of node congestion in
             wireless simulations


                            Isaac Aholu
                         iaholu@tamu.edu

                        Jeevan Joseph John
                         jeevan@tamu.edu




                   Advisor: Dr. Richard Furuta




                  Department of Computer Science
                      Texas A&M University
                    College Station, TX – 77843
                                                  Table of Contents

1. Introduction ................................................................................................................ 2
2. Previous Work............................................................................................................ 2
3. Data Source ................................................................................................................ 3
4. Trace Analysis ............................................................................................................ 4
5. Design and implementation objectives ...................................................................... 4
   A. Design Elements................................................................................................. 4
   B. Design Principles ............................................................................................... 5
   C. Implementation .................................................................................................. 5
6. The visualization ........................................................................................................ 5
7. Conclusion and future work ....................................................................................... 8
8. Bibliography............................................................................................................... 8


1. Introduction
       Node congestion analysis at present has many challenging issues. Most of
these challenges arise as a result of the lack of a meaningful way of visualizing the
congestion performance of these networks. Frequent topology changes due to node
mobility make routing in such dynamic networks a challenging problem [1]. To our
knowledge, the only available visualizations in network analysis present right now is
the network animator, which animates the flow of packets in a 2D environment. The
network animator lacks a meaningful visualization component for node congestion.
Our term project proposes to provide visualization for a sizeable amount of data
(55,607 lines) from the ns2 trace file. We want to use a visualization infrastructure to
support visualization of network congestion simulation trace data in a 2D
environment. Our implementation is done in Java with Swing components for
displaying visual representation. The purpose of this project is to give the user a visual
understanding of how network congestion work, and what the data in these trace files
represent.




2. Previous Work
        Some work has been done in the area of network animation. The Network
Simulator (ns2) by Information Sciences Institute (ISI) is one of them. This simulator
provides substantial support for the simulation of TCP, routing, and multicast
protocols over wired and wireless (local and satellite) networks. Another application
developed by ISI is the Network Animator (Nam). This is a Tcl /TK based animator
tool can be used for viewing network simulation traces and real world packet traces. It
supports topology layout, packet level animation, and various data inspection tools.
Even though the simulator and animator can generate traces, they do not really provide
any aid to help in analyzing and visualizing node congestion.



                                                                2
3. Data Source
         Our data source consists of trace files from network simulator (ns2). We had
initially considered using network animator trace file also, but it turned out to have
little information about node congestion which made us choose the network simulator
trace file as our single data source. Ns2 and nam are open source network simulation
tools that are released by the Information Sciences Institute (ISI). The ns2 trace file
consists of multiple lines of traces with each line representing a single event. Each of
these trace lines begins with a character that defines the type of event that takes place,
followed by a series of metadata describing this event. Figure 1 below gives an
example of the structure of a trace file. The first column describes the event, in this
case a receive, dequeue, enqueue and a drop. The next column gives the time at which
the even happened (time is in seconds). The third column gives information on the
node on which the event occurs i.e. the from and to node. The fifth and sixth column
gives the packet type and the packet size in Bytes. The next column represents flags.
The next is the flow id. The next two represent the source and destination address of
the form “node.port” followed by the network layer protocol‟s packet sequence
number. The last field gives the unique packet id. With all the available information
available, users can then transform the data in any column for analysis depending on
the kind of information/ analysis sought.




                          Fig 1. Trace Format Example (source [2])




                                             3
4. Trace Analysis
        In order to further explain how the analysis is done, we give an example of a
CBR packet receive [2] event which selects two columns for analysis. These columns
are the time column and the sequence number column from the above trace format and
then calculates the difference from the last packet receive time divided by the
difference in the sequence number (for loss packets) for each sequence number. Figure
2 below gives a corresponding jitter graph that was generated using gnu plot. The X-
axis represents the packet sequence number and the Y axis shows simulation time in
seconds.




                    Figure 2 CBR Jitter at the Receiving Node (Source 2)




5. Design and implementation objectives
   A. Design Elements
   Shapes: We decided to use an eclipse shape to represent our nodes since it is the
   shape that is most often associated with nodes in a 2D plan. This was to help keep
   the viewer‟s attention and focus on the node and also help mimic an optical
   perspective of the network node.
   Space: In order to create harmony we decided our layout should have the nodes on
   the left upper part of the display and the metadata and other buttons on the right
   side of the display.
   Hue: The colors used were red and its complement green, and an intermixing of
   both, with red indicating severe congestion and green indicating no congestion.
   The main reason for choosing these two colors was to take advantage of the
   psychological connotations associated with these colors in the real world. For the


                                             4
   color changes our logic was based on the event type. There were three events
   occurring in the trace file which are send („s‟) for packets sent, receive (“r”) for
   packets received and drop (“d”) for packets dropped. Based on these events, the
   node colors change according to the type of event that occurs at the node. So as the
   level of congestion increased, the color of the node drew closer to red and vice
   versa.
   Change: Our change was based on the transitions occurring at the various nodes.
   The following transitions at the nodes moved towards green meaning no
   congestion. An “s” after another “s” , “r” after “r”, “r” after “d”, “s” after “d” ,
   “s” after “r” and “r” after “s”. On the other hand the transition is towards red
   meaning severe congestion if there is a “d” after an “s”, “d” after another “d” and a
   “d” after an “r”.

   B. Design Principles
   Juxtaposition: We decided to place the nodes in our visualization close to each
   other on two lines, with the first and second nodes on one line and the third and
   fourth on the second line. The purpose of this was to force the viewer to confront
   the color changes at all the four nodes simultaneously, and also give a feel of what
   would be happening in the real-time if these nodes are sending, receiving and
   dropping packets simultaneously.
   Variation: We decided to simulate the variations at each node by using the color
   variations, with the idea of representing the non identical instances of events as
   they occur at the various nodes.
   Patterns: For patterns, we decided to iterate through each single node
   representation to stimulate sensations of change and motion in the viewers‟ vision.

   C. Implementation
   Our application was implemented with Java taking advantages of its 2D API and
   swing components.

6. The visualization
        In our implementation, node congestion is arrived at by analyzing what event
occurs at a particular node at a specific point in time. This is done by selecting the first
column in each line of the trace file. This column tells us if the node was a send,
received or if a packet has been dropped. This information is then associated with the
node ID column in order to arrive at the status of each node after each event has
occurred. These events in the tracefile are logged in a time series and are made up of
55,607 events which span over a period of about 400 seconds. So for every event,
there is information on the node at which it occurred and the time at which it occurred.




                                             5
               Fig 3. The initial state; all nodes are colored green, i.e. no congestion.

        One of the challenges we faced in the visualization is the discrete nature of the
tracefile. We have tried to give a continuous time series visualization of the
simulation. However, the data source we have represents events happening in discrete
time. The desired mapping of time to the line number in the trace file is linear.
However, with the data source being discrete, we can only get an approximate linear
mapping between time and the line number of the tracefile. The algorithm we used for
our simulation is as follows. Node color changes from green (R=0, G=255, B=0) to
red (R=255, G=0, B=0) as congestion increases and vice versa. Node color changes
from a current color to a shade of red as congestion increases , i.e. for s – d , r – d and
d- d. Node color changes from a current color to a shade of green as congestion
decreases, i.e. for s – s, r – r, d- s, d- r, s- r and r- s

         The interface we have designed is interactive and allows the user to visualize
state condition at a particular time, by entering time in the time textbox and clicking
the “Show at time” button. A time-series animation can be achieved by entering time
in the textbox and clicking the “Animate till” button. We decided to place the nodes at
the four corners of a square rather than to place it according to the geographical
position of the node. This is to enable the user to give equal attention to the events
happening in the four nodes.




                                                   6
  .
 Fig 4. The state at time t = 6.963692017 secs; nodes 1 and 2 are congested, with node 1 being more
                                    severely congested than node 2.




Fig 5. The state at time t = 392.965147794 secs; node 1 is congested more than node 2. nodes 3 and 4
                                        have little congestion.

                                                 7
7. Conclusion and future work
        The work we have presented helps to visually represent a time series
congestion of nodes in wireless networks. The interface we have designed can be
improved to dynamically select tracefiles from the file system or from a URL. Right
now, the visualizer supports only the wireless trace format. We could extent this to
visualize trace formats for wired as well as wired-cum wireless networks. We could
couple our implementation of the visualization with the ns2 simulator and provide a
more real time visualization of the simulation.

8. Bibliography
[1]. Azzedine Boukerche, Sajal K. Das: Congestion Control Performance
of R-DSDV Protocol in Multihop Wireless Ad Hoc Networks, Wireless Networks
9(3): 261-270 (2003)

[2]. Jae Chung, Mark Claypool: NS by Example, http://nile.wpi.edu/NS/
 (December 2004)

[3] ns2 documentation, http://www.isi.edu/nsnam/ns/ns-documentation.html




                                         8

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:3
posted:12/4/2011
language:English
pages:8