Escolar Documentos
Profissional Documentos
Cultura Documentos
ACKNOWLEDGEMENT
The last but not least, I express my sincere thanks to all my friends who have
supported me in the accomplishment of this project.
SATISH KUMAR.K
2
(08AR1F0043)
TABLES OF CONTENTS
1. INTRODUCTION
1.1 OVERVIEW OF THE PROJECT 12
1.2 LITRATURE SYURVEY 13
1.3 PROPOSED SYSTEM 22
1.4 OBJECTIVES & SCOPES 23
1.5 ORGANIZATION OF THE PROJECT 24
2. REQUIREMENT SPECIFICATION
2.1 OVERALL DESCIPTION 25
2.2 PRODUCT PERSPECTIVE 27
2.3 USER CHARACTRSICS 28
2.4 OPERATION ENVIRONMENT 29
2.5 CONSTRIANTS 37
2.6 SPECIFIC REQUIREMENTS 40
2.7 EXTERNAL INTERFACE REQUIREMENTS 41
2.8 SYSTEM FEATURE 42
2.9 DATA FLOW AND ER DIAGRAMS 43
2.10PERFORMANACE REQUIREMENTS 45
2.11 SOFTWARE QUALITY ATTRIBUTE 46
LIST OF FIGURES
4
5
List Of Abbrevations:
1. BRuIT -Bandwidth Reservation under InTerferences influence
1. INTRODUCTION
Since 2005, IEEE 802.11-based networks have been able to provide a certain level of quality of
service (QoS) by the means of service differentiation, due to the IEEE 802.11e amendment.
However, no mechanism or method has been standardized to accurately evaluate the amount of
resources remaining on a given channel. Such an evaluation would, however, be a good asset for
bandwidth-constrained applications. In multi hop ad hoc networks, such evaluation becomes even
more difficult. Consequently, despite the various contributions around this research topic, the
estimation of the available bandwidth still represents one of the main issues in this field. AD hoc
networks are autonomous, self-organized, wireless, and mobile networks. They do not require
setting up any fixed infrastructure such as access points, as the nodes organize themselves
automatically to transfer data packets and manage topology changes due to mobility.
7
other probes, modifying other estimations. Second, an end-to-end evaluation technique may not be
as reactive as a local technique in a mobile context. When updating routes in response to node
mobility or to a change in the available resources, local detection and reconstruction may be more
efficient in several situations.
A dynamic bandwidth management scheme for single-hop ad hoc networks is proposed in [6]. In
this solution, one node in the network hosts the Bandwidth Manager process, which is responsible
for evaluating the available bandwidth in the cell and for allocating the bandwidth to each peer.
Each node may ask the Bandwidth Manager for an exclusive access to the channel during a
proportion of time using dedicated control messages. As the topology is reduced to a single cell,
the available proportion time-share is computed by this entity considering that the total load is the
sum of the individual loads. The available fraction of time may then be translated into an available
bandwidth by considering the capacity of the wireless link, called total bandwidth in this paper,
which is deduced from a measurement of the data packets’ throughput. This approach can be
considered as passive as very few control packets are exchanged, usually of small size. However,
this solution is adapted to network topologies where all the nodes are within communication range
but cannot be directly used in multihop ad hoc networks. Even if the election, the synchronization,
and the maintenance of several Bandwidth Managers may represent a significant cost in large
distributed networks, similar measurements may be employed. When a node desires to estimate
the bandwidth available in its vicinity, the intuitive approach consists in monitoring the channel
over a given time period and to deduce from this observation the utilization ratio of the shared
resource. The method proposed in [7] uses such technique and adds a smoothing factor to hide
transient effects. The QoS routing protocol designed in this paper is based on a simple estimation
of the available bandwidth by each node and does not consider any interfering nodes. QoS-AODV
[8] also performs such a per-node ABE. The evaluation mechanism constantly updates a value
called Bandwidth Efficiency Ratio (BWER), which is the ratio between the numbers of
transmitted and received packets. The available bandwidth is simply obtained by multiplying the
BWER value by the channel capacity. This ratio is broadcasted among the one-hop neighbors of
each node through Hello messages. The bandwidth available to a node is then inferred from these
values as the minimum of the available bandwidths over a closed single-hop neighborhood. QoS-
AODV, therefore, considers not only the possibility to send a given amount of data but also the
effect of the emissions of a node on its neighborhood. In [9], Chaudet and Lassous proposed a
bandwidth reservation protocol called Bandwidth Reservation under InTerferences influence
9
(BRuIT). This protocol’s ABE mechanism takes into account the fact that, with the IEEE 802.11
standard, the carrier sense radius is larger than the transmission range. In other words, emitters
share the bandwidth with other nodes they cannot communicate with. Experimental studies have
shown that this carrier sense radius is at least twice the communication radius. To address this
issue, each node regularly broadcasts to all its immediate neighbors information about the total
bandwidth it uses to route and emit flows (deduced from applications and routing information) and
its estimated available bandwidth. It also transmits similar information concerning all its one-hop
neighbors, propagating such information at a two-hop distance. Each node then performs
admission control based on this two-hop neighborhood knowledge. When the carrier sense radius
is equal to twice the communication radius, the authors have shown that two-hop communication
represents the best compromise between estimation accuracy and cost [10]. Making the same
observation, Yaling and Kravets [11] proposed the Contention Aware Admission Control Protocol
(CACP). In this framework, each node first computes its local proportion of idle channel time by
monitoring the radio medium. Then, the authors propose three different techniques to propagate
this information to the greatest number of nodes within the carrier sense area.
First, similarly to BRuIT, they propose to include the information in Hello messages to reach the
two-hop neighborh ood.
Second, they propose to increase the nodes’ transmission power; however, this emission power is
often limited by regulations and this technique may therefore only be applicable when power
control is used for regular transmissions.
Finally, receiving nodes can also reduce their sensitivity in order to decode information coming
from farther away, which depends on the quality of electronics and on the signal modulation.
Similarly to [12], the authors also point out the existence of intraflow contention. When a flow
takes a multihop route, successive routers contend for channel access for frames belonging to the
same flow. It is thus important to take into account at least the route length when performing
admission control. Ideally, the exact
10
interactions between nodes along a path should be identified and considered. Finally, the AAC
protocol, proposed in [13], makes each node consider the set of potential contenders as a single
node. It measures the activity period durations and considers that any such period can be seen as a
frame emission of the corresponding length. With this mechanism, collisions and distant emissions
are also considered when computing the medium occupancy. Based on this measurement, each
node is able to evaluate its available bandwidth. It exchanges this information with its neighbors to
compute the bandwidth on each link, a link being defined as a pair of nodes. This value is defined
as the minimum between the available bandwidths of both ends. AAC also takes into account the
intraflow contention problem mentioned above.
11
1.4 OBJECTIVES&SCOPE
. The carrier sense mechanism prevents two close emitters from transmitting simultaneously,
unless they draw the same backoff counter value. Therefore, an emitter shares the channel
bandwidth with all its close neighbors. The channel utilization has to be monitored to evaluate the
capacity of a node to emit a given traffic volume.
. For a transmission to take place, the receiver needs that no interference occurs during the whole
transmission. Therefore, the value of the available bandwidth on a link depends on both peer
channel utilization ratios and also on the idle period synchronization. This synchronization needs
to be evaluated.
. No collision detection is possible in a wireless environment. Therefore, whenever a collision
happens, both colliding frames are completely emitted, maximizing the bandwidth loss. As shown
by the scenario depicted in Fig. 1, the collision probability
needs to be estimated and integrated to the ABE.
. Finally, when collisions happen on unicast frames, the IEEE 802.11 protocol automatically
retries to emit the same frame, drawing the backoff counter in a double-sized contention window.
The time lost in the additional overhead may also have an impact on the available bandwidth and
has to be evaluated.
Whenever a node needs to send a frame, it first needs to contend for medium access and it cannot
emit its frame unless the medium is free. Therefore, a potential sender needs to evaluate the load
of the medium, i.e., the proportion of time the medium is idle to determine the chance it has to
successfully gain access to the shared resource. Such evaluation is also performed by the solutions
proposed in [7] or [11].
13
Let us consider a node s in the network during an observation interval of _ seconds. We use the
following notations:
is the total idle time, i.e., the total time during which node s neither emits any frame nor
senses the medium busy. Both physical and virtual carrier sense mechanisms should report an idle
state. This includes periods during which no frame is ready to be emitted as well as periods of
deferral (back off time and interframe spacing).
.Bs is the bandwidth available to node s, i.e., the maximum throughput it can emit without
degrading close flow’s rate.
. Cmax is the capacity of the medium.
1.4.2 Evaluation of literature survey
It is quite tricky, from an operational point of view, to evaluate the
performance of the sole ABE part of an existing QoS protocol. Therefore, for comparison
purposes, we have integrated the previously described bandwidth evaluation technique ABE into a
protocol and implemented it under NS-2. This simulator has been chosen because of the
availability of other protocol models. We have chosen to integrate ABE into AODV, in order to be
similar to BRuIT, QoS-AODV, or AAC. It is thus based on broadcasted route request messages,
admission control at each intermediate node, and explicit reservation by a unicast route reply
message issued by the destination. We can thus study the impact of our estimation technique on
the bandwidth management in the network by comparing the performance of the different
protocols. The protocol is called hereafter ABE-AODV. The accuracy of the bandwidth evaluation
obviously depends on the value of _, which can be considered as a sampling period. The larger _
is, the more stable the measurements will be, hiding fast variations in the medium load. However,
_ should also be small enough to allow fast reactions to long-term load variations and to node
mobility. Hello-based techniques generate additional overhead depending on the Hello emission
frequency. Ideally, the Hello packet emission frequency should be adapted to the node mobility
and/or to the flow dynamics. In order to have meaningful comparisons, we chose to fix this value
to _ ¼ 1 second in ABE-AODV. Similarly, all compared protocols are tuned accordingly to emit
one information frame each second. We have slightly modified AODV in order to transform it into
a QoS protocol based on ABE. It thus becomes a cross-layer routing protocol. The MAC layer
estimates
proactively and periodically the available bandwidth of the neighboring links, and the routing
layer is in charge of discovering QoS routes complying to the application
demands, basing its decisions on the MAC layer information.
14
built on long term mutual gain, not short-term expediency. We believe that this long term mutual
gain is founded on sharing risk and responsibility with our clients. Our priority is solving
problems for you, not giving you more to worry about. We also know that forming strategic
partnerships with our clients is a key to success. We work together with both your business and
technical teams to ensure we deliver high quality solutions to meet the needs of your business.
This leaves you in control and able to build competence and knowledge within your own teams.
The closeness we develop in our working relationship with you results in reduced risk and
The Service
local relationship founded on trust and accountability. We recognize that our clients want support
that is sensitive to their priorities, focused on their business needs and always responsive to the
constant change they experience. If you have experience of working with services companies that
seem to need you to flex to the way they work, then working with Pensoft Solutions will be a
refreshing change. Pensoft Solutions staffs are able to tailor a service that exactly meets your
needs and we flex our systems to accommodate the way you work. Our services are delivered
through the Pensoft Solutions Delivery Method which has received the highest level of industry
accreditations. We do not have a fixed view of how and where we can perform services and are
keen to provide a method that meets all of your needs, taking into account other parameters such
as cost, management, skills availability and communication methods. We also recognize the need
to provide a service that can react dynamically to your business. Consequently, our management
structure is flat and our people are empowered to make decisions. If you have issues, or need to
15
escalate priorities, you are only ever one level away from the most senior management in our
organization, who are always ready to pick up the phone when you need us.
16
2. REQUIREMENTS SPECIFICATION
2.1 OVERALL DESCRIPTION
Mobile Networks
It is illusory to provide hard QoS guarantees when nodes are mobile. QoS violations appear due to the
topology changes, which result either in route breakage or in unexpected variations of the available
throughputs. In this situation, the route can either be finally broken or can be rebuilt at the source, or it
may finally be rebuilt locally. Choosing between all these strategies is not in the scope of this paper.
We present results on mobile networks only to give indication on the creativeness of the raw bandwidth
From a programming perspective, the beauty of ODBC is that the application can be
written to use the same set of function calls to interface with any data source, regardless of the
database vendor. The source code of the application doesn’t change whether it talks to Oracle or
SQL Server. We only mention these two as an example. There are ODBC drivers available for
several dozen popular database systems. Even Excel spreadsheets and plain text files can be turned
into data sources. The operating system uses the Registry information written by ODBC
Administrator to determine which low-level ODBC drivers are needed to talk to the data source
(such as the interface to Oracle or SQL Server). The loading of the ODBC drivers is transparent to
the ODBC application program. In a client/server environment, the ODBC API even handles
many of the network issues for the application programmer.
The advantages of this scheme are so numerous that you are probably thinking there must
be some catch. The only disadvantage of ODBC is that it isn’t as efficient as talking directly to the
native database interface. ODBC has had many detractors make the charge that it is too slow.
19
Microsoft has always claimed that the critical factor in performance is the quality of the driver
software that is used. In our humble opinion, this is true. The availability of good ODBC drivers
has improved a great deal recently. And anyway, the criticism about performance is somewhat
analogous to those who said that compilers would never match the speed of pure assembly
language. Maybe not, but the compiler (or ODBC) gives you the opportunity to write cleaner
programs, which means you finish sooner. Meanwhile, computers get faster every year.
JDBC
In an effort to set an independent database standard API for Java, Sun Microsystems
developed Java Database Connectivity, or JDBC. JDBC offers a generic SQL database access
mechanism that provides a consistent interface to a variety of RDBMSs. This consistent interface
is achieved through the use of “plug-in” database connectivity modules, or drivers. If a database
vendor wishes to have JDBC support, he or she must provide the driver for each platform that the
database and Java run on.
To gain a wider acceptance of JDBC, Sun based JDBC’s framework on ODBC. As you
discovered earlier in this chapter, ODBC has widespread support on a variety of platforms. Basing
JDBC on ODBC will allow vendors to bring JDBC drivers to market much faster than developing
a completely new connectivity solution.
JDBC was announced in March of 1996. It was released for a 90 day public review that
ended June 8, 1996. Because of user input, the final JDBC v1.0 specification was released soon
after.
The remainder of this section will cover enough information about JDBC for you to know what it
is about and how to use it effectively. This is by no means a complete overview of JDBC. That
would fill an entire book.
JDBC Goals
Few software packages are designed without goals in mind. JDBC is one that, because of
its many goals, drove the development of the API. These goals, in conjunction with early reviewer
feedback, have finalized the JDBC class library into a solid framework for building database
applications in Java.
The goals that were set for JDBC are important. They will give you some insight as to why
certain classes and functionalities behave the way they do. The eight design goals for JDBC are as
follows:
20
And for dynamically updating the cache table we go for MS Access database .
21
Simple Architecture-neutral
Object-oriented Portable
Distributed High-performance
Interpreted multithreaded
Robust Dynamic
Secure
Java is also unusual in that each Java program is both compiled and interpreted.
With a compile you translate a Java program into an intermediate language called Java
byte codes the platform-independent code instruction is passed and run on the
computer.
Compilation happens just once; interpretation occurs each time the program is
executed. The figure illustrates how this works.
You can think of Java byte codes as the machine code instructions for the Java
Virtual Machine (Java VM). Every Java interpreter, whether it’s a Java development
tool or a Web browser that can run Java applets, is an implementation of the Java VM.
The Java VM can also be implemented in hardware.
Java byte codes help make “write once, run anywhere” possible. You can compile
your Java program into byte codes on my platform that has a Java compiler. The byte
codes can then be run any implementation of the Java VM. For example, the same
Java program can run Windows NT, Solaris, and Macintosh.
Networking
TCP/IP stack
IP datagram’s
The IP layer provides a connectionless and unreliable delivery system. It considers each
datagram independently of the others. Any association between datagram must be supplied
by the higher layers. The IP layer supplies a checksum that includes its own header. The
header includes the source and destination addresses. The IP layer handles routing through
an Internet. It is also responsible for breaking up large datagram into smaller ones for
transmission and reassembling them at the other end.
UDP
UDP is also connectionless and unreliable. What it adds to IP is a checksum for the
contents of the datagram and port numbers. These are used to give a client/server model -
see later.
23
TCP
TCP supplies logic to give a reliable connection-oriented protocol above IP. It provides
a virtual circuit that two processes can use to communicate.
Internet addresses
In order to use a service, you must be able to find it. The Internet uses an address
scheme for machines so that they can be located. The address is a 32 bit integer which gives
the IP address. This encodes a network ID and more addressing. The network ID falls into
various classes according to the size of the network address.
Network address
Class A uses 8 bits for the network address with 24 bits left over for other addressing.
Class B uses 16 bit network addressing. Class C uses 24 bit network addressing and class D
uses all 32.
Subnet address
Internally, the UNIX network is divided into sub networks. Building 11 is currently on
one sub network and uses 10-bit addressing, allowing 1024 different hosts.
Host address
8 bits are finally used for host addresses within our subnet. This places a limit of 256
machines that can be on the subnet.
Total address
Port addresses
A service exists on a host, and is identified by its port. This is a 16 bit number. To send
a message to a server, you send it to the port for that service of the host that it is running on.
This is not location transparency! Certain of these ports are "well known".
Sockets
#include <sys/types.h>
#include <sys/socket.h>
int socket(int family, int type, int protocol);
Here "family" will be AF_INET for IP communications, protocol will be zero, and type
will depend on whether TCP or UDP is used. Two processes wishing to communicate over
a network create a socket each. These are similar to two ends of a pipe - but the actual pipe
does not yet exist.
25
Java Technology
Simple
Architecture neutral
Object oriented
Portable
Distributed
High performance
Interpreted
Multithreaded
Robust
Dynamic
Secure
With most programming languages, you either compile or interpret a program so that you can
run it on your computer. The Java programming language is unusual in that a program is both compiled
and interpreted. With the compiler, first you translate a program into an intermediate language called
Java byte codes —the platform-independent codes interpreted by the interpreter on the Java platform.
The interpreter parses and runs each Java byte code instruction on the computer. Compilation happens
just once; interpretation occurs each time the program is executed. The following figure illustrates how
this works.
26
You can think of Java bytecodes as the machine code instructions for the Java Virtual
Machine (Java VM). Every Java interpreter, whether it’s a development tool or a Web browser that can
run applets, is an implementation of the Java VM. Java bytecodes help make “write once, run
anywhere” possible. You can compile your program into bytecodes on any platform that has a Java
compiler. The bytecodes can then be run on any implementation of the Java VM. That means that as
long as a computer has a Java VM, the same program written in the Java programming language can
run on Windows 2000, a Solaris workstation, or on an iMac.
You’ve already been introduced to the Java VM. It’s the base for the Java platform and is
ported onto various hardware-based platforms.
The Java API is a large collection of ready-made software components that provide many
useful capabilities, such as graphical user interface (GUI) widgets. The Java API is grouped
into libraries of related classes and interfaces; these libraries are known as packages. The next
section, What Can Java Technology Do?, highlights what functionality some of the packages
in the Java API provide.
The following figure depicts a program that’s running on the Java platform. As the figure
shows, the Java API and the virtual machine insulate the program from the hardware.
Native code is code that after you compile it, the compiled code runs on a specific
hardware platform. As a platform-independent environment, the Java platform can be a bit
slower than native code. However, smart compilers, well-tuned interpreters, and just-in-time
bytecode compilers can bring performance close to that of native code without threatening
portability.
How does the API support all these kinds of programs? It does so with packages of software
components that provide a wide range of functionality. Every full implementation of the Java
platform gives you the following features:
• The essentials: Objects, strings, threads, numbers, input and output, data
structures, system properties, date and time, and so on.
• Security: Both low level and high level, including electronic signatures,
public and private key management, access control, and certificates.
We can’t promise you fame, fortune, or even a job if you learn the Java programming
language. Still, it is likely to make your programs better and requires less effort than other
languages. We believe that Java technology will help you do the following:
• Avoid platform dependencies with 100% Pure Java: You can keep your
program portable by avoiding the use of libraries written in other languages. The
100% Pure JavaTM Product Certification Program has a repository of historical
process manuals, white papers, brochures, and similar materials online.
• Write once, run anywhere: Because 100% Pure Java programs are
compiled into machine-independent bytecodes, they run consistently on any Java
platform.
2.5 CONSTRAINTS
Route Discovery
The aim of the route discovery procedure is to find a route between the sender and the
receiver that meets the constraints specified by the application level in terms of bandwidth. Therefore,
30
two flows with the same source and destination can follow different routes depending on the network
state.
When a source node has data to send, it broadcasts a route request (RREQ) to its neighbors. The RREQ
packet contains the address of the sender, the channel use, the requirements at the application level, the
destination address, and a sequence number. Each mobile node that receives such an RREQ performs
an admission control by simply comparing the bandwidth requirement carried in the RREQ packet to
the estimated available bandwidth on the link it received the RREQ on. If this check is positive, the
node adds its own address to the route and forwards the RREQ; otherwise, it silently discards the
message. This step is different from the other tested protocols as the admission control is done at the
receiver side and not at the sender side. This is explained by the fact that, in ABE, each node stores the
available bandwidths of its ingoing links. Finally, if the destination receives a first RREQ, it sends a
unicast route reply (RREP) to the initiator of the request along the reverse path. The resources are then
Simply comparing the bandwidth application requirement and a link available bandwidth is not
sufficient to decide about the network ability to convey a flow. Indeed, the intraflow contention
problem has to be considered when performing multihop admission control. In [12], the authors
compute a value called contention count (CC) of a node along a given path. This value is equal to the
number of nodes on the multihop path that are located within the carrier sensing range of the
considered node. To calculate the CC of each node, the authors analyze the distribution of the signal
power.As in [17], for simplicity reasons, in ABE, we rather use a direct relationship between the end-
to-end throughput and the number of hops. Hence, after consideration of the intraflow contention on an
intermediate node j, which is located at H hops from the source and has received the RREQ from a
several simulations with different parameters such as network load, flow maximum throughput, number
of nodes, and network diameter. A few general results apply to all simulated protocols. For instance,
when the network load is low, all protocols yield similar results, even the non-QoS-enabled ones. Flow
QoS degradation and false admission control phenomena begin to appear when congestion rises above
a certain level. On the opposite, when the network load is too high or when the flows’ individual
throughputs are too important, very few flows are admitted. In this case, the problem falls ack to the
sole intraflow contention problem for which all solutions have similar answers.
32
The feasibility of the project is analyzed in this phase and business proposal is put forth
with a very general plan for the project and some cost estimates. During system analysis the feasibility
study of the proposed system is to be carried out. This is to ensure that the proposed system is not a
burden to the company. For feasibility analysis, some understanding of the major requirements for the
system is essential.
Three key considerations involved in the feasibility analysis are
♦ ECONOMICAL FEASIBILITY
♦ TECHNICAL FEASIBILITY
♦ SOCIAL FEASIBILITY
ECONOMICAL FEASIBILITY
This study is carried out to check the economic impact that the system will have on the
organization. The amount of fund that the company can pour into the research and development of the
system is limited. The expenditures must be justified. Thus the developed system as well within the
budget and this was achieved because most of the technologies used are freely available. Only the
customized products had to be purchased.
TECHNICAL FEASIBILITY
This study is carried out to check the technical feasibility, that is, the technical
requirements of the system. Any system developed must not have a high demand on the available
technical resources. This will lead to high demands on the available technical resources. This will lead
to high demands being placed on the client. The developed system must have a modest requirement, as
only minimal or null changes are required for implementing this system.
SOCIAL FEASIBILITY
The aspect of study is to check the level of acceptance of the system by the user. This
includes the process of training the user to use the system efficiently. The user must not feel threatened
by the system, instead must accept it as a necessity. The level of acceptance by the users solely depends
on the methods that are employed to educate the user about the system and to make him familiar with
it. His level of confidence must be raised so that he is also able to make some constructive criticism,
which is welcomed, as he is the final user of the system.
34
Fig 3.8.1
35
Sender
Receiver
Bandwidth
Estimation for
IEEE 802.11
Based Ad
Hoc
Networks
Level 1 DFD
Node2
RR
EQ
EQ RR
RR EP
EP +
Node1 RR Node4
RR
EQ+
Node3
36
By using recommendation algorithm we can group errors by category based on type of error the system
provide recommendation in the form of feedback. So it gives good performance, feedback flexible,
reliable, secure and maintainable
Price in economics and business is the result of an exchange and from that trade we assign a
numerical monetary value to a good, service or asset
Accessibility is a general term used to describe the degree to which a product, device, service,
or environment is accessible by as many people as possible. Accessibility can be viewed as the "ability
to access" and possible benefit of some system or entity. Accessibility is often used to focus on people
with disabilities and their right of access to the system.
Availability is the degree to which a system, subsystem, or equipment is operable and in
acommittable state at the start of a mission, when the mission is called for at an unknown, i.e., a
random, time. Simply put, availability is the proportion of time a system is in a functioning condition.
Maintenance is the ease with which a software product can be modified in order to:
correct defects
meet new requirements
make future maintenance easier, or
cope with a changed environment
The idea that something is fit for purpose with respect to time;
The capacity of a device or system to perform as designed;
The resistance to failure of a device or system;
The ability of a device or system to perform a required function under stated
conditions for a specified period of time;
The probability that a functional unit will perform its required function for a specified
interval under stated conditions.
Scalability applies to technology and business settings. Regardless of the setting, the base concept is
consistent - The ability for a business or technology to accept increased volume without impacting the
system.In telecommunications and software engineering, scalability is a desirable property of a system,
a network, or a process, which indicates its ability to either handle growing amounts of work in a
graceful manner or to be readily enlarged.
Security is the degree of protection against danger, loss, and criminals. Security has to be compared
and contrasted with other related concepts: Safety, continuity, reliability. The key difference between
security and reliability is that security must take into account the actions of people attempting to cause
destruction. Security as a state or condition is resistance to harm. From an objective perspective, it is a
structure's actual (conceptual and never fully knowable) degree of resistance to harm.
39
unless they draw the same backoff counter value. Therefore, an emitter shares the channel bandwidth
with all its close neighbors. The channel utilization has to be monitored to evaluate the capacity of a
2. For a transmission to take place, the receiver needs that no interference occurs during the whole
transmission. Therefore, the value of the available bandwidth on a link depends on both peer channel
utilization ratios and also on the idle period synchronization. This synchronization needs to be
evaluated.
happens, both colliding frames are completely emitted, maximizing the bandwidth loss. The collision
4. Finally, when collisions happen on unicast frames, the IEEE 802.11 protocol automatically retries to
emit the same frame, drawing the backoff counter in a double-sized contention window. The time lost
in the additional overhead may also have an impact on the available bandwidth and has to be evaluated.
40
The Unified Modeling Language allows the software engineer to express an analysis model using the
modeling notation that is governed by a set of syntactic semantic and pragmatic rules.
A UML system is represented using five different views that describe the system from distinctly
different perspective. Each view is defined by a set of diagram, which is as follows.
• User Model View
i. This view represents the system from the users perspective.
ii. The analysis representation describes a usage scenario from the end-users
perspective.
Use case Diagrams represent the functionality of the system from a user’s point of view. Use cases are
used during requirements elicitation and analysis to represent the functionality of the system. Use cases
focus on the behavior of the system from external point of view.
Actors are external entities that interact with the system. Examples of actors include users like
administrator, bank customer …etc., or another system like central database.
node
Apply
Source RREQ
Sourcer
RREP
43
Send
the
data
View the
details
Destination
Sourcer
Class Diagram
44
Node 2
length,cond
Node2 ser ()
Initialize Component()
Node1
Node 3
i,m,value
message,time,d
initi al ize component()
Action performed() Node3()
Server()
Node 4
i,m,n,k,cond
Node4()
Action P erformed()
State Diagram
45
Sender
Packet
Creation
Apply
RREQ
Get RREP
Destination
Activity Diagram
46
Input Data
Desti nation
Sequence Diagram
47
RRE P
Collaboration Diagram
48
1: RREQ Network
Sourc e
Form ation
2: R REP
M es s age
Transform ation
49
Component Diagram
The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each test type
addresses a specific testing requirement.
TYPES OF TESTS
Unit testing
Unit testing involves the design of test cases that validate that the internal program logic is
functioning properly, and that program input produce valid outputs. All decision branches and internal
code flow should be validated. It is the testing of individual software units of the application .it is done
after the completion of an individual unit before integration. This is a structural testing, that relies on
knowledge of its construction and is invasive. Unit tests perform basic tests at component level and test
a specific business process, application, and/or system configuration. Unit tests ensure that each unique
path of a business process performs accurately to the documented specifications and contains clearly
defined inputs and expected results.
Integration testing
Integration tests are designed to test integrated software components to determine if they
actually run as one program. Testing is event driven and is more concerned with the basic outcome of
screens or fields. Integration tests demonstrate that although the components were individually
satisfaction, as shown by successfully unit testing, the combination of components is correct and
consistent. Integration testing is specifically aimed at exposing the problems that arise from the
combination of component
Functional test
51
Functional tests provide a systematic demonstrations that functions tested are available as
specified by the business and technical requirements, system documentation , and user manuals.
Functional testing is centered on the following items:
Valid Input : identified classes of valid input must be accepted.
Invalid Input : identified classes of invalid input must be rejected.
Functions : identified functions must be exercised.
Output : identified classes of application outputs must be exercised.
Systems/Procedures : interfacing systems or procedures must be invoked.
System Test
System testing ensures that the entire integrated software system meets requirements. It tests a
configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions and
flows, emphasizing pre-driven process links and integration points.
Unit testing is usually conducted as part of a combined code and unit test phase of the
software lifecycle, although it is not uncommon for coding and unit testing to be conducted as two
distinct phases.
Test objectives
• All field entries must work properly.
• Pages must be activated from the identified link.
• The entry screen, messages and responses must not be delayed.
Features to be tested
• Verify that the entries are of the correct format
• No duplicate entries should be allowed
• All links should take the user to the correct page.
IMPLEMENTATION
53
SAMPLING CODING
Source Coding
/****************************************************************/
/* Node1 */
/* */
/****************************************************************/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.io.*;
import java.net.*;
import java.sql.*;
import java.rmi.*;
import java.rmi.server.*;
public class Node1 extends JFrame implements ActionListener
{
private JTabbedPane jTabbedPane1;
private JPanel contentPane;
private JTextField jTextField2;
private JLabel jLabel1;
private JTextArea jTextArea1;
private JScrollPane jScrollPane2;
private JTextArea jTextArea2;
private JScrollPane jScrollPane3;
private JButton jButton1;
private JButton jButton2;
private JButton jButton3;
private JButton jButton4;
private JButton jButton5;
private JButton jButton6;
private JPanel jPanel1;
private JComboBox jComboBox1;
private JPanel jPanel2;
private int i,m,n,k=0,length1,value,cond=0;
long time,d;
String pac[];
String s;
String message;
Socket client1;
Socket S1;
ServerSocket server1;
public Node1()
{
super();
initializeComponent();
54
this.setVisible(true);
try
{
server1=new ServerSocket(11);}
jTabbedPane1.setFont(new Font("Arial",Font.BOLD,13));
jTabbedPane1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e)
{
jTabbedPane1_stateChanged(e);
}
});
jLabel1.setText("Destination Node :");
contentPane.setLayout(null);
addComponent(contentPane, jTabbedPane1, 55,49,523,433);
jTextField2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jTextField2_actionPerformed(e);
}
});
jTextArea1.setText("");
jScrollPane2.setViewportView(jTextArea1);
jScrollPane3.setViewportView(jTextArea2);
jButton1.setText("Browse");
jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton1_actionPerformed(e);
}
});
jButton2.setText("RREQ");
jButton2.addActionListener(this);
jButton3.setText("Exit");
jButton3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton3_actionPerformed(e);
}
});
jButton5.setText("SEND");
jButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton5_actionPerformed(e);
}
});
jButton6.setText("CLEAR");
jButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton6_actionPerformed(e);
56
}
});
jButton4.setText("Exit");
jButton4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton4_actionPerformed(e);
}
});
jPanel1.setLayout(null);
addComponent(jPanel1, jTextField2, 19,144,223,22);
addComponent(jPanel1, jScrollPane2, 21,195,220,193);
addComponent(jPanel1, jButton1, 266,140,78,28);
addComponent(jPanel1, jButton2, 267,200,71,28);
addComponent(jPanel1, jComboBox1, 130,52,100,22);
addComponent(jPanel1, jLabel1, 22,52,112,18);
addComponent(jPanel1,jButton5,267,250,71,28);
addComponent(jPanel1,jButton6,267,300,72,28);
addComponent(jPanel1, jButton3, 267,360,71,28);
jPanel2.setLayout(null);
addComponent(jPanel2, jScrollPane3, 80,50,343,295);
addComponent(jPanel2,jButton4,208,360,83,28);
this.setTitle("Node1 - extends JFrame");
this.setLocation(new Point(0, 0));
this.setSize(new Dimension(600, 534));
}
private void addComponent(Container container,Component c,int x,int y,int width,int
height)
{
c.setBounds(x,y,width,height);
container.add(c);
}
private void jComboBox1_actionPerformed(ActionEvent e)
{
System.out.println("\njComboBox1_actionPerformed(ActionEvent e) called.");
Object o = jComboBox1.getSelectedItem();
System.out.println(">>" + ((o==null)? "null" : o.toString()) + " is selected.");
}
private void jTabbedPane1_stateChanged(ChangeEvent e)
{
System.out.println("\njTabbedPane1_stateChanged(ChangeEvent e) called.");
}
private void jTextField2_actionPerformed(ActionEvent e)
{
System.out.println("\njTextField2_actionPerformed(ActionEvent e) called.");
}
private void jButton1_actionPerformed(ActionEvent e)
57
{
System.out.println("\njButton1_actionPerformed(ActionEvent e) called.");
try
{
s="";
int b;
FileDialog fd=new FileDialog(this,"Open",FileDialog.LOAD);
fd.show();
FileInputStream fis=new FileInputStream(fd.getDirectory()+fd.getFile());
jTextField2.setText(fd.getDirectory()+fd.getFile());
while((b=fis.read())!=-1)
{
message+=(char)b;
}
jTextArea1.setText(message);
}
catch(Exception r)
{
r.printStackTrace();
}
}
public void actionPerformed(ActionEvent e)
{
String valu="";
String check=""+jComboBox1.getSelectedItem();
if((e.getSource())==jButton2)
{
cond=1;
try
{
// Interface
is=(Interface)Naming.lookup("//192.168.1.2/Server");
Interface is=(Interface)Naming.lookup("//localhost/Server");
value=is.retrieve1(check);
}
catch (Exception ew)
{
ew.printStackTrace();
}
}
}
private void jButton3_actionPerformed(ActionEvent e)
{
this.dispose();
}
private void jButton4_actionPerformed(ActionEvent e)
{
58
this.dispose();
}
private void jButton6_actionPerformed(ActionEvent e)
{
jTextArea1.setText("");
}
private void jButton5_actionPerformed(ActionEvent e)
{
int chk=0;
try
{
if(cond==1)
{
if(jComboBox1.getSelectedItem().equals("Node2"))
{
JOptionPane.showMessageDialog(this,"Message send to Node2");
m=22;
n=22;
}
else if(jComboBox1.getSelectedItem().equals("Node3"))
{
JOptionPane.showMessageDialog(this,"Message send to Node3");
m=33;
n=33;
}
else if(jComboBox1.getSelectedItem().equals("Node4"))
{
if(value==0)
{
m=22;
n=44;
JOptionPane.showMessageDialog(this,"Message send to Node2");
}
else
{
m=33;
n=44;
JOptionPane.showMessageDialog(this,"Message send to Node3");
}
}
else if(jComboBox1.getSelectedItem().equals("Node5"))
{
JOptionPane.showMessageDialog(this,"Message send to Node5");
m=55;
}
client1=new Socket("localhost",m);
DataOutputStream out=new DataOutputStream(client1.getOutputStream());
59
if(out!=null)
{
out.flush();
}
time=System.currentTimeMillis();
int b=11;
out.writeInt(b);
out.writeInt(n);
out.writeLong(time);
int outgoing=0;
byte buffer[]=message.getBytes();
int len=buffer.length;
int tlength=buffer.length/48;
int length11=buffer.length%48;
int len1=len;
if(length11!=0)
{
tlength++;
}
out.writeInt(tlength);
int st=0;
int end=48;
System.out.println("Message Length: "+len);
String prefinal="tytyt";
String finalst="";
if (len<=48)
{
finalst=prefinal+message+"\n"+"null";
System.out.println("Message: "+message);
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message);
}
else
{
System.out.println("Message: "+message.substring(st,end));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(st,end));
Thread.sleep(1000);
while(len1>48)
{
len1-=48;
if(len1<=48)
{
System.out.println("Message: "+message.substring(end,len));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(end,len));
}
60
else
{
int sp=end+48;
System.out.println("Message: "+message.substring(end,sp));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(end,sp));
end=sp;
}
}
}
String del="Data Transmission is completed";
JOptionPane.showMessageDialog(this,del);
// Interface
i=(Interface)Naming.lookup("//192.168.1.2/Server");
Interface i=(Interface)Naming.lookup("//localhost/Server");
chk=i.delete();
Thread.sleep(1500);
if(chk==0)
{
System.out.println("database items are deleted");
}
long flen=message.length();
out.writeLong(flen);
--cond;
}
else
{
String check="confirm the RREQ";
JOptionPane.showMessageDialog(this,check);
}
}
catch (Exception exp)
{
exp.printStackTrace();
}
}
public void Server()
{
try
{
int count=0;
String rr[];
S1=server1.accept();
DataInputStream dis=new DataInputStream(S1.getInputStream());
int source=dis.readInt();
jTextArea1.append("Source Address "+source+"\n");
int s=dis.readInt();
61
int c=length;
pac=new String[length];
System.out.println("length===="+length);
while(length>0)
{
pac[count]=dis.readUTF();
jTextArea2.append("\n\nPacket " + "-->\n***********\n"+pac[count]);
length--;
count++;
}
d=dis.readLong();
Socket client4=new Socket("localhost",s);
DataOutputStream dout=new DataOutputStream(client4.getOutputStream());
dout.writeInt(source);
dout.writeInt(s);
dout.writeLong(sender_time);
System.out.println(""+sender_time);
dout.writeInt(c);
for(int q=0;q<count;q++)
{
dout.writeUTF(pac[q]);
}
dout.writeLong(d);
}
}
catch (Exception exp)
{
exp.printStackTrace();
}
}
//============================= Testing
================================//
//= =//
//= The following main method is just for testing this class you built.=//
//= After testing,you may simply delete it. =//
//============================================================
==========//
public static void main(String[] args)
{
Node1 node =new Node1();
while(true)
{
node.Server();
}
//= End of Testing =
63
}
}
RESULTS
Node 1
64
Node 2
65
Node 3
66
Node 4
67
Click on RREQ button and select the destination node from the drop down list
69
These results show that single-hop flows and multihop flows are admitted more
As future works, we plan to focus on two issues. First, in our current evaluation, we make no difference
between the bandwidth consumed by QoS flows and the bandwidth consumed by best effort flows.
Therefore, it may be possible that a node considers its available bandwidth on a link as almost null
whereas the whole bandwidth is consumed by best effort flows. Decreasing the rate of these flows may
Differentiating flow types may also result in a better utilization of the network resources. In
parallel, we are investigating the delay metric, as preliminary studies indicate that some parts of the
approach described in this paper may be used or converted to this other important parameter
75
5.3 REFERENCE
BIBLIOGRAPHY
5.3 Appendixes
76