Mini Project final report on " LEAKY BUCKET ALGORITHM "

LEAKY BUCKET ALGORITHM
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING,BCE,S.BELAGOLA - 1 -
CHAPTER 1
INTRODUCTION
1.1 Overview of Computer Graphics
Computer Graphics (CG) become a powerful tool for the rapid and economical
production of pictures. There is virtually no area in which Graphical displays cannot be used
to some advantage so it is not surprising to find the use of CG so widespread.
Although early application in engineering & science had to rely on expensive &
cumbersome equipment’s, advances in computer technology have made interactive computer
graphics a practical tool. Today Computer Graphics is found in diverse area such as science,
engineering, medicine, business, industry, government, art, entertainment, education and
training
1.2 History
William fetter was credited with coining the term Computer Graphics in 1960, to
describe his work at Boeing. One of the first displays of computer animation was future
world (1976), which included an animation of a human face and hand-produced by Carmull
and Fred Parkle at the University of Utah.
There are several international conferences and journals where the most
significant results in computer-graphics are published. Among them are the SIGGRAPH
and Euro graphics conferences and the association for computing machinery (ACM)
transaction on Graphics journals.
1.3 Applications of computer graphics
Nowadays Computer Graphics used in almost all the areas ranges from
science, engineering, medicine, business, industry, government, art, entertainment, education
and training.
1.3.1 CG in the field of CAD
Computer Aided Design methods are routinely used in the design of buildings,
automobiles, aircraft, watercraft, spacecraft computers, textiles and many other applications.

1.3.2 CG in presentation Graphics
Graphics used to produce illustrations for reports or generate slides. Presentation
graphics is commonly used to summarize financial, statistical, mathematical, scientific data
for research reports and other types of reports.2D and 3D bar chart to illustrate some
mathematical or statistical report.
1.3.3 CG in computer Art
CG methods are widely used in both fine art and commercial art applications.
Artists use a variety of computer methods including special purpose hardware, artist’s
paintbrush program, other pain packages, desktop packages, mathematical packages,
animation packages that provide facility for designing object motion. Ex: cartoons decision is
an example of computer art which uses CG.
1.3.4 Entertainment
Computer graphics methods are now commonly used in making motion pictures,
music, videos, games and sounds. Sometimes graphics objects are combined with the actors
and live scenes.
1.3.5 Education and Training
Computer generated models of physical financial, economic system is often used
as education aids. For some training application special systems are designed.
Ex: Specialized system is simulator for practice sessions or training of ship captain, aircraft
pilots and traffic control.
1.3.6 Image Processing
Although the methods used in CG image processing overlap, the 2 areas are
concerned with fundamentally different operations. In CG a computer is used to create
picture. Image processing on the other hand applies techniques to modify existing pictures
such as photo scans, TV scans.
1.3.7 User Interface
It is common for software packages to provide a graphical interface. A major
component of a graphical interface is a window manager that allows a user to display
multiple window area. Interface also displays menus, icons for fast selection and processing.

1.4 Problem Statement
To implement the Traffic shaping by “Leaky bucket Algorithm” using OpenGL
functions different shapes and movement for objects like polygon. Here user has to insert
capacity of the bucket and transmission rate for which the outcome will be regulated packets.
1.5 Objective of the project
The main objective of this project is to graphically illustrate the concept of traffic
shaping ‘LEAKY BUCKET ALGORITHM’ using OpenGL. The implementation can be
made more effective using OpenGL in C++ basis following obstacles
 To determine time of transmission with limit of bandwidth and burstiness.
 To implement the concept of queue in packet flow.
 To convert turbulent incoming packets into smooth, regular stream of packets.
1.6 Organizationof the Report
Chapter 1 introduces the computer graphics and its applications. Chapter 2
discusses basic concepts and principles involved in OpenGL. Chapter 3 deals with the basic
concepts ant working principles. Chapter 4 deals with design and implementation, results and
snapshots. Chapter 5 concludes the project and at the end the references used for the project
are listed.

CHAPTER 2
INTRODUCTION TO OPENGL
OpenGL is a software interface to graphics hardware. This interface consists of about
150 distinct commands that you use to specify the objects and operations needed to produce
interactive three-dimensional applications. OpenGL is designed as a streamlined, hardware-
independent interface to be implemented on many different hardware platforms.
Most of the application will be designed to access OpenGL directly through functions
in three libraries. Functions in the main GL (or OpenGL in windows) library have names that
begin with the letters gl and are stored in a library usually referred to as GL (or OpenGL in
windows). The second is the OpenGL Utility Library (GLU). This library uses only GL
functions but contains code for creating common objects and simplifying viewing. All
functions in GLU can be created from the core GL library but application programmers
prefer not to write the code repeatedly. The GLU library is available in all OpenGL
implementations; functions in the GLU library begin with letters glu.
To interface with the window system and to get input from external devices into our
programs, at least one more system-specific library. For each major window system there is a
system-specific library that provides the “glue” between the window system and OpenGL.
For the X window system, this library is called GLX, for Windows, it is wgl, and for the
Macintosh, it is agl. Rather than using a different library for each system, The use of readily
available library called the OpenGL Utility Toolkit (GLUT), which provides the minimum
functionality that should be expected in any modern windowing system.
Fig 2.1 shows the organization of the libraries for an X Window System environment.
For this window system, GLUT will use GLX and the X libraries. The application program,
however, can use only GLUT functions and thus can be recompiled with the GLUT library
for other window systems.
2.1 OpenGL Command Syntax
OpenGL commands use the prefix gl and initial capital letters for each word
making up the command name. Similarly, OpenGL defined constant begin with GL_, use all
capital letters, and use underscores to separate words (like GL_COLOR_BUFFER_BIT).

Fig 2.1 Library organization
Some extraneous letters are appended to some command name (for example, the 3f
in glColor3f( ) and glVertex3f( )). It’s true that the Color part of the command name
glColor3f( ) is enough to define the command as one that sets the current color. However,
more than one such command has been defined so as to use different types of arguments. In
particular, the 3 part of the suffix indicates that three arguments are given; another version of
the Color command takes four arguments. The f part of the suffix indicates that the
arguments are floating point numbers. Having different formats allows OpenGL to accept the
user’s data.
Some OpenGL commands accept as many as 8 different data types for their
arguments.
2.1.1 Pixel Operation
Pixels from an array in system memory are first unpacked from one of a variety of
formats into the proper number of components. Next the data is scaled, biased, and processed
by a pixel map. The results are clamped and then either written into texture memory or sent
to the rasterization step. If the pixel data is read from the frame buffer, pixel transfer
operations (scale, bias, mapping, and clamping) are performed.
Then these results are packed into an appropriate format and returned to an
array in system memory. There are special pixel copy operations to copy data in the frame
buffer to other parts of the frame buffer or to the texture memory. A single pass is made
OpenGL
application
Program
GLU
GL
GLUT
GLX
Xlib, Xtk
Frame
Buffer

through the pixel transfer operations before the data is written to the texture memory or back
to the frame buffer.
2.2 OpenGL as a State Machine
OpenGL is a state machine. It is put into various states (or modes) that then remain
in effect until it is changed. The current color is state variable. The current color can be set to
white, red or any other color, and thereafter every object is drawn with that color until current
color is set to something else.
Many state variables refer to modes that are enabled or disabled with the
command glEnable( ) and glDisable( ).Each state variable or mode has a default value, and
at any point the system can be queried for each variable’s current value. Typically one of the
following six commands can be used to do this: glGetBooleanv(), glDoublev(),
glGetFloatv(), glGetIntegerv(), glGetPointerv(), or glEnabled().
2.3 Display Lists
All data, whether it describes geometry or pixel, can be saved in a display lists for
current or latter use. When a display list is executed, the retained data is sent from the display
list just as if it were sent by the application in immediate mode.
2.4 Evaluators
All geometric primitives are eventually described by vertices. Parametric curves
and surfaces may be initially described by control points and polynomial functions called
basis functions. Evaluators provide a method to derive the vertices used to represent the
surface from the control points. The method is a polynomial mapping, which can produce
surface normal, texture coordinates, colors, and spatial coordinate values from the control
points.
2.5 Primitive Assembly
Clipping, a major part of primitive assembly, is the elimination of portions of
geometry which fall outside a half-space, defined by a plane. Point clipping simply passes or
rejects vertices; line or polygon clipping can add additional vertices depending upon how the

line or polygon is clipped. In some cases, this is followed by perspective division, which
makes distant geometric objects appear smaller than closer objects.
Then viewport and depth (z coordinate) operations are applied. Is culling is enabled and the
primitive is a polygon, it then may be rejected by a culling test. Depending upon the polygon
mode, a polygon may be drawn as points or lines.
2.6 Pixel Operations
Pixels from an array in system memory are first unpacked from one of a variety of
formats into the proper number of components. Next the data is scaled, biased, and processed
by a pixel map. The results are clamped and then either written into texture memory or sent
to the rasterization step.
If the pixel data is read from the frame buffer, pixel transfer operations (scale, bias,
mapping, and clamping) are performed. Then these results are packed into an appropriate
format and returned to an array in system memory. There are special pixel copy operations to
copy data in the frame buffer to other parts of the frame buffer or to the texture memory. A
single pass is made through the pixel transfer operations before the data is written to the
texture memory or back to the frame buffer.
2.7 Texture Assembly
An OpenGL application may wish to apply texture images onto geometric objects
to make them look more realistic. Some OpenGL implementations may have special
resources to accelerate texture performance. There may be specialized, high-performance
texture memory.
2.8 Rasterization
Rasterization is the conversion of both geometric and pixel data into
fragments. Each fragment square corresponds to a pixel in the frame buffer. Line and
polygon stipples, line width, point size, shading model, and coverage calculations to support
antialiasing are taken into consideration as vertices are connected into lines or interior pixels
are calculated for a filled polygon. Color and depth values are assigned for each fragment
square.

2.9 Fragment Operations
Before values are actually stored into frame buffer, a series of operations are
performed that may alter or even throw out fragments. All these operations can be enabled or
disabled. The operation which may be encountered texturing, where a texel (texture element)
is generated from texture memory for each fragment and applied to the fragment. Then fog
calculations may be applied, followed by scissor test, the alpha test, the stencil test, and the
depth-buffer test.
2.10 Needof OpenGL
The intension of this chapter is to give you basic concepts in OpenGL. OpenGL is
a device and operating system independent library for 3D-graphics and rendering. OpenGL
was originally developed b Silicon Graphics Inc (SGI) for use on their high end graphics
workstations. Since then, OpenGL has become a widely accepted standard with
implementations on many operating system and hardware platforms including Windows NT
and Windows X operating systems.
The purpose of OpenGL library is to render two or three-dimensional objects into
frame buffer. OpenGL is a library of high-quality three-dimensional graphics and rendering
functions. The library’s device- and platform- independence make it a library of choice for
developing portable graphical applications.
OpenGL drawings are constructed from primitives; primitives are simple items such
as lines or polygons, which in turn are composed of vertices. The OpenGL library assembles
primitives from vertices while taking into account a variety of settings, such as color,
lighting, and texture. Primitives are then processed in accordance with transformations,
clipping settings, and other parameters; at the end of the rasterization process is pixel data
deposited into a frame buffer.
Because of high visual quality and performance any visual computing
application requiring maximum performance-from 3D animation to CAD to visual
simulation-can exploit high-quality, high-performance OpenGL capabilities. These
capabilities allow developers in diverse markets such as broadcasting, CAD/CAM/CAE,
entertainment, medical imaging, and virtual reality to produce and display incredibly
compelling 2D and 3D graphics.

2.11 Advantage of Using OpenGL
 Stable: OpenGL implementations have been available for more than seven years on a
wide variety of platforms. Additions to the specification are well controlled, and proposed
updates are announced in time for developers to adopt changes. Backward compatibility
requirement ensure that existing applications do not become obsolete.
 Reliable and Portable: all OpenGL applications produce consistent visual display
results on any OpenGL API-compliant hardware, regardless of operating system or
windowing system.
 Evolving: Because of its thorough and forward-looking design, OpenGL allows new
hardware innovations to be accessible through API via the OpenGL extension mechanism.

CHAPTER 3
BASIC CONCEPTS AND RULES
3.1 Traffic Access Control
A collection of specification techniques and mechanisms to:
 specify the expected traffic characteristics and service requirements (e.g. peak rate,
required delay bound, loss tolerance) of a data stream
 shape data streams (e.g. reducing their rates and/or Traffic Burstiness) at the edges
and selected points within the network
 police data streams and take corrective actions (e.g. discard, delay, or mark packets)
when traffic deviates from its specification
 real-time queuing and scheduling mechanisms require some control of the rate and
burstiness of data moving through the system.
3.2 Traffic Access Control Functions
Flow specification function
Provides the common language by which applications and network elements communicate
service requirements.
a) Shaping function
b) Policing function
Monitors traffic flows and takes corrective actions when the observed characteristics deviate
from those specified.
The location of policing functions (e.g. at the network edge and at stream merge points) are
usually determined by the network providers.
3.3 Goal
limit traffic to not exceed declared parameters.
The result of traffic shaping is a smoothed packet output rate.
3.4 Traffic Shaping Algorithms
1. Leaky Bucket
2.Token Bucket

3.4.1 LeakyBucket
The Leaky bucket is an algorithm converts any turbulent incoming traffic into
smooth, regular stream of packets. It can be used to check the data communications in the
form of packets. The Leaky Bucket algorithm is based on the analogy of bucket has a hole
in the bottom through which any water it contains will leak away at a constant rate, until it is
empty.
Fig3.1
(a)A leaky bucket with water. (b)A leaky bucket with packets
Water can be added intermittently, but if too much is added at once then water will
exceed the capacity of bucket, which will overflow.Hence, this leaky bucket determines
whether adding some amount of water would exceed or conform to limit on average rate at
which water can be added, set by leak rate and limit on how much water can be added in a
burst, set by the depth of bucket.

Two different methods of applying this leaky bucket are counter and queue. It can
use queue in flow of traffic. Queue is used to directly control the flow. When the packets
are entered into the queue as they arrive, the packets are removed from the queue, at a fixed
rate. As a result, rate at which queue is serviced directly controls the transmission rate of
traffic. This can be used in packet switched computer networks and telecommunication
networks.
Fig 3.2:Packet dropping out in overflow
A leaky bucket interface is connected between packet transmitter and the network. No
matter at what rate packet enter the traffic shaper, Outflow is regulated at a constant rate.
At first the display asks us to enter
1. Capacity of the bucket.
2. Capacity of the transmission line.
After entering all the above parameters now on pressing ‘s’ in the keyboard the packets
arrives in the mean time, the count increases. If the count exceeds the capacity of the bucket
the packets overflows, otherwise continues with the flow.

CHAPTER 4
DESIGN AND IMPLEMENTATION
4.1 Design
It specifies how the packets flow when the required condition satisfies. Here the
packet will move in constant rate When the capacity of the bucket becomes full the packet
will overflow.
Yes
No
Yes
No
X=value of leaky bucket counter
X’=auxiliary variable
LCT=last conformance time
Fig 4.1 Flow Diagram
Arrival of a packet
at a time ta
X’=X-(ta-LCT)
X’<0
?
X’=0
X’>L?
X=X’+I
LCT=ta
Conforming packet
Nonconforming
packets

4.2 IMPLEMENTATION
 glutInit
Syntax: glutInit( int *argc, char ** argv);
Purpose: Initializes GLUT. The arguments from main are passed
In and can be used by the application.
 glVertex
Syntax: a)glVertex[234][sifd]( TYPE xcoordinate, TYPE ycoordinate, …);
b) glVertex[234][sifd]v(TYPE *coordinate);
Purpose: Specifies the position of a vertex in 2,3,or 4 dimensions. The coordinates can
be specified as short s, int i, float f or double d. If the v is present, the argument is a
pointer to an array containing the coordinates.
 glutCreateWindow
Syntax: glutCreateWindow(char * title);
Purpose: It creates a window on the display. The string title can be used to label the
window.
 glutInitDisplayMode
Syntax: glutInitDisplayMode( unsigned int mode);
Purpose: It requests a display with the properties in mode. The value of mode is
determined by the logical OR of options including the color model(GLUT_RGB) and for
buffering(GLUT_SINGLE, GLUT_DOUBLE).
 glutMainLoop
Syntax: glutMainLoop();
Purpose: It causes the program to enter an event processing loop. It should be the last
statement in main.
 glutKeyboardFunc
Syntax: glutKeyboardFunc(void *f(char key, int width, int height)
Purpose: Registers the keyboard callback function f. The callback function returns the
ASCII code of the key pressed and the position of the mouse.

 glEnd
Syntax: glEnd();
Purpose: Terminates a list of vertices.
 glBegin
Syntax: glBegin(glEnum mode);
Purpose: Initiates a new primitive of type mode and and starts the collection of vertices.
Values of mode include GL_POINTS, GL_LINES and GL_POLYGON.
 glLoadIdentity
Syntax: glLoadIdentity();
Purpose: It loads the identity matrix.
 glMatrixMode
Syntax: a) glMatrixMode(GL_PROJECTION);
b) glMatrixMode(GL_MODEL_VIEW);
Purpose: It helps in selecting the matrix(model view or projection matrix) to which the
operations apply by setting the matrix mode; a variable that is set to one type of matrix
and also part of the state.
 glutSwapBuffers()
As all of our drawing thus far has been back buffer, and not the screen, this command
is required to take the information on back buffer, and send it to the front in one massive
swap. This is where what’s been drawn previously actually gets sent to the screen.
 glutPostRedisplay()
This function alters Glut that the screen needs to be redrawn, forcing it to call the
draw() function again at the next possible opportunity. By including this immediately after
the call to swap the buffers, It improvise our own display loop that runs as fast as the
computer can handle. In general, you can put this command in any function that modifies
what appears on the screen.

4.3 REQUIREMENT SPECIFICATION
In this section the various requirements that are essential for this project are specified.
These requirements have to be fulfilled for execution of the project. The purpose, Scope
along with hardware and software requirements are given below:
 System Requirements
4.4.1 Software Requirements
 Operating System- Windows XP
 GLUT library and OpenGL package
 Microsoft Visual basic C++ 6.0
4.4.2 Hardware Requirements
 Processor - Pentium 4
 Hard Disk
 Memory - 512 MB
 Mouse - 3 button mouse
 Keyboard – necessary
 Visual Display Unit

CHAPTER 5
Results And Snapshots
Fig 5.1 Front Screen

Fig 5.2: Output of Leaky Bucket
Fig 5.2 shows the arrival of packets as soon as we press the respected keys.

Fig 5.3: Flow of packetin free bucket
Fig 5.3 shows the flow of packets out of the bucket in a regulated manner

Fig 5.4: Packet dropping out in overflow
Fig 5.4 shows the overflow of packets when the bucket is flow, it will not affect
the regulated flow of the packets.

CONCLUSION AND FUTURE SCOPE
Conclusion
By doing the leaky bucket algorithm in OpenGL we come to know the translation
function and various other library functions in OpenGL.
The project started with the designing phase where figured the requirements needed
in the system design, Data flow diagram etc. Then comes the details of the implementation
phase where it have come across with various functionalities. And now after the testing
phase,the project comes to an end with this report.
Future Scope
The “LEAKY BUCKET ALGORITHM” can be further improvised to show delay
analysis and traffic shaping.

REFERENCES
[1]. Communication Networks – Fundamental Concepts & key architectures, Alberto Leon
Garcia & Indra Widjaja, 2nd Edition, Tata McGraw-Hill, India.
[2]. William Stallings: Data and Computer Communication, 8th Edition, Pearson Education,
2007.
[3]. Leaky Bucket Algorithm, www.slideshare.net
[4]. Edward Angel: Interactive Computer Graphics A Top-Down Approach with OpenGL, 5th
edition, Pearson Education, 2008.

Mini Project final report on " LEAKY BUCKET ALGORITHM "

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Mini Project final report on " LEAKY BUCKET ALGORITHM "

Similaire à Mini Project final report on " LEAKY BUCKET ALGORITHM " (20)

Plus de Nikhil Jain

Plus de Nikhil Jain (9)

Dernier

Dernier (20)

Mini Project final report on " LEAKY BUCKET ALGORITHM "