New Microsoft Word Document(1)

Bandwidth recyling in ieee 802.16 networks

Bandwidth Recycling in IEEE 802.16 Networks

1. INTRODUCTION

The Worldwide Interoperability for Microwave Access (WiMAX), based on

IEEE 802.16 standard standards, is designed to facilitate services with high

transmission rates for data and multimedia applications in metropolitan areas. The

physical (PHY) and medium access control (MAC) layers of WiMAX have been

specified in the IEEE 802.16 standard. Many advanced communication technologies

such as Orthogonal Frequency-Division Multiple Access (OFDMA) and multiple-

input and multiple-output (MIMO) are embraced in the standards.Supported by these

modern technologies,WiMAX is able to provide a large service coverage, high data

rates and QoS guaranteed services. Because of these features,WiMAX is considered

as a promising alternative for last mile broadband wireless access (BWA).In order to

provide QoS guaranteed services, the subscriber station (SS) is required to reserve the

necessary bandwidth from the base station (BS) before any data transmissions. In

order to serve variable bit rate (VBR) applications, the SS tends to keep the reserved

bandwidth to maintain the QoS guaranteed services.Thus, the amount of reserved

bandwidth transmitted data may be more than the amount of transmitted data and may

not be fully utilized all the time. Although the amount of reserved bandwidth is

adjustable via making bandwidth requests (BRs), the adjusted bandwidth is applied as

early as to the next coming frame. The unused bandwidth in the current frame has no

chance to be utilized. Moreover, it is very challenging to adjust the amount of

reserved bandwidth precisely. The SS may be exposed to the risk of degrading the

QoS requirements of applications due to the insufficient amount of reserved

bandwidth.

To improve the bandwidth utilization while maintaining the same QoS

guaranteed services, our research objective is twofold: 1) the existing bandwidth

reservation is not changed to maintain the same QoS guaranteed services. 2) our

research work focuses on increasing the bandwidth utilization by utilizing the unused

bandwidth. We propose a scheme, named Bandwidth Recycling, which recycles the

unused bandwidth while keeping the same QoS guaranteed services without

introducing

MRITS-Department Of IT 1


extra delay. The general concept behind our scheme is to allow other SSs to utilize the

unused bandwidth left by the current transmitting SS. Since the unused bandwidth is

not supposed to occur regularly, our scheme allows SSs with non-real time

applications, which have more flexibility of delay requirements, to recycle the unused

bandwidth. Consequently, the unused bandwidth in the current frame can be utilized.

It is different from the bandwidth adjustment in which the adjusted bandwidth is

enforced as early as in the next coming frame. Moreover, the unused bandwidth is

likely to be released temporarily (i.e., only in the current frame) and the existing

bandwidth reservation does not change. Therefore, our scheme improves the overall

throughput while providing the same QoS guaranteed services.

According to the IEEE 802.16 standard, SSs scheduled on the uplink (UL) map

should have transmission opportunities in the current frame. Those SSs are called

transmission SSs (TSs) in this paper. The main idea of the proposed scheme is to

allow the BS to schedule a backup SS for each TS. The backup SS is assigned to

standby for any opportunities to recycle the unused bandwidth of its corresponding

TS. We call the backup SS as the complementary station (CS). In the IEEE 802.16

standard, BRs are made in per-connection basis. However, the BS allocates bandwidth

in per-SS basis. It gives the SS flexibility to allocate the granted bandwidth to each

connection locally. Therefore, the unused bandwidth is defined as the granted

andwidth which is still available after serving all connections running on the SS. In

our scheme, when a TS has unused bandwidth, it should transmit a message, called

releasing message (RM), to inform its corresponding CS to recycle the unused

bandwidth. However, because of the variety of geographical distance between TS and

CS and the transmission power of the TS, the CS may not receive the RM. In this

case, the benefit of our scheme may be reduced. In this research, we investigate the

probability that the CS receives a RM successfully. Our theoretical analysis shows

that this probability is least 42%, which is confirmed by our simulation. By further

investigating the factors that affect the effectiveness of our scheme, two factors are

concluded: 1) the CS cannot receive the RM. 2) the CS does not have non-real time

data to transmit while receiving a RM. To mitigate those factors, additional

scheduling algorithms are proposed. Our simulation results show that the proposed

algorithm further improve the average throughput by 40% in a steady network (i.e.,

second in our simulation).



The structure of a MAC frame defined in IEEE 802.16 standard contains two parts:

UL and DL subframe. The UL subframe is for UL transmissions. Similarly, the DL

subframe is for DL transmissions. In IEEE 802.16 networks, the SS is coordinated by

the BS. All coordinating information including burst profiles and offsets is in

the DL and UL maps, which are broadcasted at the beginning of a MAC frame.

The IEEE 802.16 network is connection-oriented. It gives the advantage of having

better control over network resource to provide QoS guaranteed services. In

order to support wide variety of applications, the IEEE 802.16 standard classifies

traffic into five scheduling classes: Unsolicited Grant Service (UGS), Real Time

Polling Service (rtPS), Non-real Time Polling Service (nrtPS), Best Effort (BE) and

Extended Real Time Polling Service (ertPS). Each application is classified into one of

the scheduling classes and establish a connection with the BS based on its scheduling

class. The BS assigns a connection ID (CID) to each connection. The bandwidth

reservation is made based on the CID via sending a BR. When receiving a BR, the BS

can either grant or reject the BR depending on its available resources and scheduling

policies. There are two types of BRs defined in the IEEE 802.16 standard: ncremental

and aggregate BRs. The former allow the SS to indicate the extra bandwidth required

for a connection. Thus, the amount of reserved bandwidth can be only increased via

incremental BRs. On the other hand, the SS specifies the current state of queue for the

particular connection via a aggregate request. The BS resets its perception of that

service’s needs upon receiving the request. Consequently, the reserved bandwidth ay

be decreased.

To improve the bandwidth utilization while maintaining the same QoS guaranteed

services, our research objective is twofold: 1) the existing bandwidth reservation is

not changed to maintain the same QoS guaranteed services. 2) our research work

focuses on increasing the bandwidth utilization by utilizing the unused bandwidth. We

propose a scheme, named Bandwidth Recycling, which recycles the unused

bandwidth while keeping the same QoS guaranteed services without introducing extra

delay. The general concept behind our scheme is to allow other SSs to utilize the

unused bandwidth left by the current transmitting SS. Since the unused bandwidth is

not supposed to occur regularly, our scheme allows SSs with non-real time

applications, which have more flexibility of delay requirements, to recycle the unused

bandwidth. Consequently, the unused bandwidth in the current frame can be utilized.

It is different from the bandwidth adjustment in which the adjusted bandwidth is



enforced as early as in the next coming frame. Moreover, the unused bandwidth is

likely to be released temporarily (i.e., only in the current frame) and the existing

bandwidth reservation does not change. Therefore, our scheme improves the overall

throughput while providing the same QoS guaranteed services.

There are two types of BRs defined in the IEEE 802.16 standard: incremental

and aggregate BRs. The former allow the SS to indicate the extra bandwidth required

for a connection. Thus, the amount of reserved bandwidth can be only increased via

incremental BRs. On the other hand, the SS specifies the current state of queue for the

particular connection via a aggregate request. The BS resets its perception of that

service’s needs upon receiving the request. Consequently, the reserved bandwidth

may be decreased.

1.1 Motivation

Bandwidth reservation allows IEEE 802.16 networks to provide QoS guaranteed

services. The SS reserves the required bandwidth before any data transmissions. Due

to the nature of VBR applications, it is very difficult for the SS to make the optimal

bandwidth reservation. It is possible that the amount of reserved bandwidth is more

than the demand. Therefore, the reserved bandwidth cannot be fully utilized.

Although the reserved bandwidth can be adjusted via BRs, however, the updated

reserved bandwidth is applied as early as to the next coming frame and there is no

way to utilize the unused bandwidth in the current frame. In our scheme, the

SS releases its unused bandwidth in the current frame and another SS pre-assigned by

the BS has opportunities to utilize this unused bandwidth. This improves

the bandwidth utilization. Moreover, since the existing bandwidth reservation is not

changed, the same QoS guaranteed services are provided without introducing

any extra delay. Many research works related to bandwidth utilization inprovement

have been proposed in the literature. In a dynamic resource reservation mechanism is

proposed.

It can dynamically change the amount of reserved resource depending on the actual

number of active connections. The investigation of dynamic bandwidth reservation

for hybrid networks is presented in . The authors evaluated the performance and

effectiveness for the hybrid network, and proposed efficient methods to ensure



optimum reservation and utilization of bandwidth while minimizing signal blocking

probability and signaling cost. In the authors enhanced the system throughput

by using concurrent transmission in mesh mode. The authors in proposed a new QoS

control scheme by considering MAC-PHY cross-layer resource allocation. A dynamic

bandwidth request-allocation algorithm for real-time services is proposed in. The

authors predict the amount of bandwidth to be requested based on the information of

the backlogged amount of traffic in the queue and the rate mismatch between packet

arrival and service rate to improve the bandwidth utilization. The research works

listed above improve the performance by predicting the traffic coming in the future.

Instead of prediction, our scheme can allow SSs to accurately identify the portion of

unused bandwidth and provides a method to recycle the unused bandwidth. It can

improve the utilization of bandwidth while keeping the same QoS guaranteed services

and introducing no extra delay.

1.2 Problem Definition

The IEEE 802.16 standard specifies three types of transmission mediums

supported as the physical layer (PHY): single channel (SC), Orthogonal frequency-

division multiplexing (OFDM) and Orthogonal Frequency-Division Multiple Access

(OFDMA). We assume OFDMA as the PHY in our analytical model since it is

employed to support mobility in IEEE 802.16e standard and the scheme working in

OFDMA should also work in others. There are four types of modulations supported

by OFDMA: BPSK, QPSK, 16-QAM and 64-QAM. This paper is focused on the

point-to-multipoint (PMP) mode in which the SS is not allowed to communicate with

any other SSs but the BS directly. Based on the transmission direction, the

transmissions between BS and SSs are classified into downlink (DL) and uplink (UL)

transmissions. The former are the transmissions from the BS to SSs. Conversely, the

latter are the transmissions in the opposite direction. There are two transmission

modes: Time Division Duplex (TDD) and Frequency Division Duplex (FDD)

supported in IEEE 802.16. Both UL and DL transmissions can not be operated

simultaneously in TDD mode but in FDD mode. In this paper, our scheme is focused

the TDD mode. In WiMAX, the BS is responsible for scheduling both UL and DL

transmissions. All scheduling behavior is expressed in a MAC frame.

The structure of a MAC frame defined in IEEE 802.16 standard contains two

parts: UL and DL subframe. The UL subframe is for UL transmissions. Similarly, the



DL subframe is for DL transmissions. In IEEE 802.16 networks, the SS is coordinated

by the BS. All coordinating information including burst profiles and offsets is in the

DL and UL maps, which are broadcasted at the beginning of a MAC frame. The IEEE

802.16 network is connection-oriented. It gives the advantage of having better control

over network resource to provide QoS guaranteed services. In order to support wide

variety of applications, the IEEE 802.16 standard classifies traffic into five scheduling

classes: Unsolicited Grant Service (UGS), Real Time Polling Service (rtPS), Non-real

Time Polling Service (nrtPS), Best Effort (BE) and Extended Real Time Polling

Service (ertPS). Each application is classified into one of the scheduling classes and

establish a connection with the BS based on its scheduling class. The BS assigns a

connection ID (CID) to each connection. The bandwidth reservation is made based on

the CID via sending a BR. When receiving a BR, the BS can either grant or reject the

BR depending on its available resources and scheduling policies. There are two types

of BRs defined in the IEEE 802.16 standard: incremental and aggregate BRs. The

former allow the SS to indicate the extra bandwidth required for a connection. Thus,

the amount of reserved bandwidth can be only increased via incremental BRs. On the

other hand, the SS specifies the current state of queue for the particular connection via

a aggregate request. The BS resets its perception of that service’s needs upon

receiving the request. Consequently, the reserved bandwidth may be decreased.

1.3 Objective of the project

The objectives of our research are twofold: 1) The same QoS guaranteed

services are provided by maintaining the existing bandwidth reservation. 2) the

bandwidth utilization is improved by recycling the unused bandwidth.To achieve

these objectives, our scheme named Bandwidth Recycling is proposed. The main idea

of the

proposed scheme is to allow the BS to pre-assign a CS for each TS at the beginning of

a frame. The CS waits for the possible opportunities to recycle the unused bandwidth

of its corresponding TS in this frame. The CS information scheduled by the BS is

resided in a list, called complementary list (CL). The CL includes the mapping

relation between each pair of pre-assigned CS and TS. As shown in Fig. 1, each CS is

mapped to at least one TS. The CL is broadcasted followed by the UL map. To reach

the backward compatibility, a broadcast CID (B-CID) is attached in front of the CL.

Moreover, a stuff byte value (SBV) is transmitted followed by the B-CID to



distinguish the CL from other broadcast DL transmission intervals. The UL map

including burst profiles and offsets of each TS is received by all SSs within the

network. Thus, if a SS is on both UL map and CL, the necessary information (e.g.,

burst profile) residing in the CL may be reduced to the mapping information between

the CS and its corresponding TS. The BS only specifies the burst profiles for the SSs

which are only scheduled on the CL.

For example, as shown in Fig. 1, CSj is scheduled as the corresponding CS of TSj ,

where 1 ≤ j ≤ k. When TSj has unused bandwidth, it performs our protocol introduced

in Section 4.1. If CSj receives the message sent from TSj , it starts to transmit data by

using the agreed burst profile. The burst profile of a CS is resided on either the UL

map if the CS is also scheduled on the UL map or the CL if the CS is only scheduled

on CL. Our proposed scheme is presented into two parts: the protocol and the

scheduling algorithm. The protocol describes how the TS identifies the unused

bandwidth and informs recycling opportunities to its corresponding CS. The

scheduling algorithm helps the BS to schedule a CS for each TS.

Limitations of project:

One of the factors causing recycling failures is that the CS does not have data

to transmit while receiving a RM. To alleviate this factor, we propose to schedule SSs

which have rejected BRs in the last frame because it can ensure that the SS scheduled

as CS has data to recycle the unused bandwidth. This scheduling algorithm is called

Rejected Bandwidth Requests First Algorithm (RBRFA). It is worth to notice that the

RBRFA is only suitable to heavily loaded networks with rejected BRs sent from non-

real time connections (i.e., nrtPS or BE). Notice that only rejected BRs sent in the last

frame are considered in the RBRFA for scheduling the current frame. The RBRFA is

summarized .The BS grants or rejects BRs based on its available resource and

scheduling policy. In RBRFA, if the BSgrants partially amount of bandwidth

requested by a BR, then this BR is also considered as a rejected BR. Similar Ot

represents the set of SSs which transmission period overlaps with the TS, St, in QR.

All SSs in Qt are considered as possible CSs of St. A rejected BR shows that the SS

must have extra data to be transmitted in the next frame and no bandwidth is allocated

for these data. The RBRFA schedules those SSs as CSs on the CL, so the probability

to recycle the unused bandwidth while the CS receives the RM is increased. The

other factor that may affect the performance of bandwidth recycling is the probability



of the RM to be received by the CS successfully. To increase this probability, a

scheduling algorithm, named history-Based Scheduling Algorithm (HBA), is

proposed. The HBA is summarized . For each TS, the BS maintains a list, called

Black List (BL). The basic CID of a CS is recorded in the BL of the TS if this CS

cannot receive RMs sent from the TS. According to our protocol, the CS transmits

data or pad the rest of transmission interval if a RM is received. The BS considers that

a CS cannot receive the RM from its corresponding TS if the BS does not receive

either data or padding information from the CS. When the BS schedules the CS of

each TS in future frames, the BS only schedules a SS which is not on the BL of the

TS as the CS. After collecting enough history, the BL of each TS should contains the

basic CID of all SSs which cannot receive the RM sent from the TS. By eliminating

those SS, the BS should have high probability to schedule a CS which can receive the

RM successfully. Therefore, BAcan increase the probability of scheduling a SS

which is able to receive the RM as the CS.

To support the mobility, the BL of each TS should be updated periodically.



Literature survey

2.1 Introduction

Literature survey is the most important step in software development process.

Before developing the tool it is necessary to determine the time factor, economy n

company strength. Once these things r satisfied, ten next steps are to determine which

operating system and language can be used for developing the tool. Once the

programmers start building the tool the programmers need lot of external support.

This support can be obtained from senior programmers, from book or from websites.

Before building the system the above consideration r taken into account for

developing the proposed system

Definition 1: Bandwidth

Is a measure of frequency range, measured in hertz.

Example

The range of frequencies within which the performance of the antenna, with respect to

some characteristics, conforms to a specified standard. (2.4-2.5GHz antenna has

100MHz bandwidth).

Definition 2: Bandwidth

The amount of data that can be transmitted in a fixed amount of time, expressed in

bits per second(bps) or bytes per second.

2.2 Existing system

Important part in bringing out the network services lies in existing technology.

Routing and switching are the main methods of delivering the data through the

network. Both have their disadvantages and benefits and there are many variations of

them applying in different ways to different situations. Another big issue is the

resource handling with QoS. In IP world, there are a few proposals to resource

handling problems and besides that there are a few technologies providing different

approaches to QoS problems. These include for instance ATM and Gigabit Ethernet.

Switching

Data transmission by purely switching the traffic through the network is the method

used traditionally in telecommunications systems. Essentially switching means that a


http://www.blurtit.com/q876299.html




constant bandwidth is allocated from the total bandwidth of the transmission medium

and the whole allocated bandwidth is used for data interchange for the time that the

bandwidth allocation is taking place. Normally, this kind of bandwidth usage is

connection oriented and requires the interchange to contain different phases including

connection establishment, data interchange and connection closing.

In fact this kind of a switching is normally accomplished at OSI protocol stack layer

2, which is the link layer. Throughout this text this kind of a switching is regarded as

layer 2 switching. Actually, layer 2 switching can simply be considered bridging and

in this logic, layer 3 switching is routing .

Routing

In turn, routing is the the main method used in TCP/IP networks nowadays. Routing

uses the bandwidth in a different way. It does not allocate constant bandwidth.

Instead, in routing, the data is transported in packages that are delivered through the

network by searching for the right directions in network nodes that are called routers.

Therefore routing is regarded as connectionless and it does not require the data

interchange phases that are needed in switching. Routing could be thought as a way of

optimizing the bandwidth usage.

2.4Proposed System

Bandwidth reservation allows IEEE 802.16 networks to provide QoS guaranteed

services. The SS reserves the required bandwidth before any data transmissions. Due

to the nature of VBR applications, it is very difficult for

the SS to make the optimal bandwidth reservation. It is possible that the amount of

reserved bandwidth is more than the demand. Therefore, the reserved bandwidth

cannot be fully utilized. Although the reserved bandwidth can be adjusted via BRs,

however, the updated reserved bandwidth is applied as early as to the next coming

frame and there is no way to utilize the unused bandwidth in the current frame. In our

scheme, the

SS releases its unused bandwidth in the current frame and another SS pre-assigned by

the BS has opportunities to utilize this unused bandwidth. This improvesthe

bandwidth utilization. Moreover, since the existing bandwidth reservation is not

changed, the same QoS guaranteed services are provided without introducing any

extra delay



2.5 Conclusion

The main purpose of this literature survey or literature review is to make a

body of text that aims to review the critical points of current knowledge including

substantive findings as well as theoretical and methodological contributions to a

particular topic. Literature reviews are secondary sources, and as such, do not report

any new or original experimental work.

The Agent-Based Intrusion Detection systems, naïve bayes model, decision

trees all have set of features that help the intrusion detection to take place in an

efficient manner. The vast available knowledge in the field of network security that

utilizes these set of features along with the various consequences one might face with

intrusions and how they can classify the attacks are described in this survey. These

attacks are:

Attack 1 – Distributed denial of service

Attack 2 – Worms

Attack 3 – Attacks on the Internet Domain Name System (DNS)

Attack 4 – Attacks against or using route



3. ANALYSIS

3.1 INTRODUCTION

System Analysis is the detailed study of the various operations performed by

the system and their relationships within and outside the system. Analysis is the

process of breaking something into its parts so that the whole may be understood.

System analysis is concerned with becoming aware of the problem, identifying the

relevant and most decisional variables, analyzing and synthesizing the various factors

and determining an optimal or at least a satisfactory solution. During this a problem is

identified, alternate system solutions are studied and recommendations are made

about committing the resources used to design the system.

This project is aimed to develop an intrusion detection system that addresses

the two issues of Accuracy and Efficiency using Conditional Random Fields and

Layered Approach. We demonstrate that high attack detection accuracy can be

achieved by using Conditional Random Fields and high efficiency by implementing

the Layered Approach. Finally, we show that our system is robust and is able to

handle noisy data without compromising performance.

SOFTWARE REQUIREMENT SPECIFICATION

JAVA

Initially the language was called as “oak” but it was renamed as “Java” in 1995. The

primary motivation of this language was the need for a platform-independent (i.e.,

architecture neutral) language that could be used to create software to be embedded in

various consumer electronic devices.

Java is a programmer’s language.

Java is cohesive and consistent.



Except for those constraints imposed by the Internet environment, Java gives the

programmer, full control.

Finally, Java is to Internet programming where C was to system programming.

Importance of Java to the Internet

Java has had a profound effect on the Internet. This is because; Java expands the

Universe of objects that can move about freely in Cyberspace. In a network, two

categories of objects are transmitted between the Server and the Personal computer.

They are: Passive information and Dynamic active programs. The Dynamic, Self-

executing programs cause serious problems in the areas of Security and probability.

But, Java addresses those concerns and by doing so, has opened the door to an

exciting new form of program called the Applet.

Java can be used to create two types of programs

Applications and Applets: An application is a program that runs on our Computer

under the operating system of that computer. It is more or less like one creating using

C or C++. Java’s ability to create Applets makes it important. An Applet is an

application designed to be transmitted over the Internet and executed by a Java –

compatible web browser. An applet is actually a tiny Java program, dynamically

downloaded across the network, just like an image. But the difference is, it is an

intelligent program, not just a media file. It can react to the user input and

dynamically change.

Features of Java Security

Every time you that you download a “normal” program; you are risking a viral

infection. Prior to Java, most users did not download executable programs frequently,

and those who did scan them for viruses prior to execution. Most users still worried

about the possibility of infecting their systems with a virus. In addition, another type

of malicious program exists that must be guarded against. This type of program can

gather private information, such as credit card numbers, bank account balances, and

passwords. Java answers both these concerns by providing a “firewall” between a

network application and your computer.

When you use a Java-compatible Web browser, you can safely download Java applets

without fear of virus infection or malicious intent.



1. PORTABILITY

For programs to be dynamically downloaded to all the various types of platforms

connected to the Internet, some means of generating portable executable code is

needed .As you will see, the same mechanism that helps ensure security also helps

create portability. Indeed, Java’s solution to these two problems is both elegant and

efficient.

2. BYTECODE

The key that allows the Java to solve the security and portability problems is that the

output of Java compiler is Byte code. Byte code is a highly optimized set of

instructions designed to be executed by the Java run-time system, which is called the

Java Virtual Machine (JVM). That is, in its standard form, the JVM is an interpreter

for byte code. Translating a Java program into byte code helps makes it much easier

to run a program in a wide variety of environments. The reason is, once the run-time

package exists for a given system, any Java program can run on it.

Although Java was designed for interpretation, there is technically nothing about Java

that prevents on-the-fly compilation of byte code into native code. Sun has just

completed its Just in Time (JIT) compiler for byte code. When the JIT compiler is a

part of JVM, it compiles byte code into executable code in real time, on a piece-by-

piece, demand basis. It is not possible to compile an entire Java program into

executable code all at once, because Java performs various run-time checks that can

be done only at run time. The JIT compiles code, as it is needed, during execution.

3. JAVA VIRTUAL MACHINE (JVM)

Beyond the language, there is the Java virtual machine. The Java virtual machine is an

important element of the Java technology. The virtual machine can be embedded

within a web browser or an operating system. Once a piece of Java code is loaded

onto a machine, it is verified. As part of the loading process, a class loader is invoked

and does byte code verification makes sure that the code that’s has been generated by

the compiler will not corrupt the machine that it’s loaded on. Byte code verification

takes place at the end of the compilation process to make sure that is all accurate and

correct. So byte code verification is integral to the compiling and executing of Java

code.



Java is unusual in that each Java program is both complied and interpreted.

With a compiler, you translate a Java program into an intermediate language called

Java byte codes – the platform independent codes interpreted by the Java interpreter.

With an interpreter, each Java byte code instruction is parsed and run on the

computer. Compilation happens just once; interpretation occurs each time the

program is executed. This figure illustrates how it works:

FIGURE 10: JAVA PROGRAM EXECUTION 1

You can think of Java byte codes as the machine code instructions for the Java

Virtual Machine (JVM). Every Java interpreter, whether it’s a Java development tool

or a Web browser that can run Java applets, is an implementation of JVM. That JVM

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 any platform that has a

Java compiler. The byte codes can then be run on any implementation of the JVM.

For example, that same Java program can e run on Windows NT, Solaris and

Macintosh.


Java program Complier

InterpreterInterpreterInterpreter


PC-Compatible Sun Ultra Solaris Windows NT Macintosh


Java Architecture

Java architecture provides a portable, robust, high performing environment for

development. Java provides portability by compiling the byte codes for the Java

Virtual Machine, which is then interpreted on each platform by the run-time

environment. Java is a dynamic system, able to load code when needed from a

machine in the same room or across the planet.

5. C0MPILATION OF CODE

When you compile the code, the Java compiler creates machine code (called byte

code) for a hypothetical machine called Java Virtual Machine (JVM). The JVM is

supposed to execute the byte code. The JVM is created for overcoming the issue of

portability. The code is written and compiled for one machine and interpreted on all

machines. This machine is called Java Virtual Machine.

Compiling and interpreting Java Source Code


Source Code………..………..

………..

…………

PC Compiler

MacintoshCompiler

SPARC

Compile

r

Java

Byte code

(PlatformIndependent)

JavaInterpreter(PC)

JavaInterpreter(Macintosh)

JavaInterpreter(Spare)



During run-time the Java interpreter tricks the byte code file into thinking that it is

running on a Java Virtual Machine. In reality this could be a Intel Pentium Windows

95 or SunSARC station running Solaris or Apple Macintosh running system and all

could receive code from any computer through Internet and run the Applets.

6. SIMPLE

Java was designed to be easy for the Professional programmer to learn and to use

effectively. If you are an experienced C++ programmer, learning Java will be even

easier. Because Java inherits the C/C++ syntax and many of the object oriented

features of C++. Most of the confusing concepts from C++ are either left out of Java

or implemented in a cleaner, more approachable manner. In Java there are a small

number of clearly defined ways to accomplish a given task.

7. OBJECT-ORIENTED

Java was not designed to be source-code compatible with any other language. This

allowed the Java team the freedom to design with a blank slate. One outcome of this

was a clean usable, pragmatic approach to objects. The object model in Java is simple

and easy to extend, while simple types, such as integers, are kept as high-performance

non-objects.

8. ROBUST

The multi-platform environment of the Web places extraordinary demands on a

program, because the program must execute reliably in a variety of systems. The

ability to create robust programs was given a high priority in the design of Java. Java

is strictly typed language; it checks your code at compile time and run time.

Java virtually eliminates the problems of memory management and de-allocation,

which is completely automatic. In a well-written Java program, all run time errors can

–and should –be managed by your program.

THE JAVA PLATFORM



A platform is the hardware or software environment in which a program runs.

The Java platform differs from most other platforms in that it’s a software-only

platform that runs on top of other, hardware-based platforms. Most other platforms

are described as a combination of hardware and operating system.

The Java platform has two components:

The Java Virtual Machine (JVM)

The Java Application Programming Interface (Java API)

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 (packages) of related components. The following

figures depict a Java program, such as an application or applet, that’s running on the

Java platform. As the figure shows, the Java API and Virtual Machine insulates the

Java program from hardware dependencies.

FIGURE 13: JAVA PLATFORM

As a platform-independent environment, Java can be a bit slower than native

code. However, smart compliers, well-tuned interpreters and just-in-time byte

compiler’s bring java’s performance close to that of native code without threatening

portability.

JAVA DATABASE CONNECTIVITY

What Is JDBC?

JDBC is a Java API for executing SQL statements. (As a point of interest, JDBC is a

trademarked name and is not an acronym; nevertheless, JDBC is often thought of as

standing for Java Database Connectivity. It consists of a set of classes and interfaces

written in the Java programming language. JDBC provides a standard API for

tool/database developers and makes it possible to write database applications using a

pure Java API.



Using JDBC, it is easy to send SQL statements to virtually any relational database.

One can write a single program using the JDBC API, and the program will be able to

send SQL statements to the appropriate database. The combinations of Java and

JDBC lets a programmer write it once and run it anywhere.

What Does JDBC Do?

Simply put, JDBC makes it possible to do three things:

Establish a connection with a database

Send SQL statements

Process the results.

JDBC versus ODBC and other APIs

At this point, Microsoft's ODBC (Open Database Connectivity) API is that probably

the most widely used programming interface for accessing relational databases. It

offers the ability to connect to almost all databases on almost all platforms.

So why not just use ODBC from Java? The answer is that you can use ODBC from

Java, but this is best done with the help of JDBC in the form of the JDBC-ODBC

Bridge, which we will cover shortly. The question now becomes "Why do you need

JDBC?" There are several answers to this question:

ODBC is not appropriate for direct use from Java because it uses a C interface. Calls

from Java to native C code have a number of drawbacks in the security,

implementation, robustness, and automatic portability of applications.

A literal translation of the ODBC C API into a Java API would not be desirable. For

example, Java has no pointers, and ODBC makes copious use of them, including the

notoriously error-prone generic pointer "void *". You can think of JDBC as ODBC

translated into an object-oriented interface that is natural for Java programmers.

ODBC is hard to learn. It mixes simple and advanced features together, and it has

complex options even for simple queries. JDBC, on the other hand, was designed to

keep simple things simple while allowing more advanced capabilities where required.

A Java API like JDBC is needed in order to enable a "pure Java" solution. When

ODBC is used, the ODBC driver manager and drivers must be manually installed on

every client machine. When the JDBC driver is written completely in Java, however,

JDBC code is automatically installable, portable, and secure on all Java platforms

from network computers to mainframes.

Two-tier and Three-tier Models



The JDBC API supports both two-tier and three-tier models for database access.

In the two-tier model, a Java applet or application talks directly to the database. This

requires a JDBC driver that can communicate with the particular database

management system being accessed. A user's SQL statements are delivered to the

database, and the results of those statements are sent back to the user. The database

may be located on another machine to which the user is connected via a network. This

is referred to as a client/server configuration, with the user's machine as the client, and

the machine housing the database as the server. The network can be an Intranet,

which, for example, connects employees within a corporation, or it can be the

Internet.


JAVAApplication

JDBC

DBMS

Client machine

DBMS-proprietary protocol

Database

server

Java applet orHtml browser

ApplicationServer (Java)

JDBC

DBMS

Client machine (GUI)

HTTP, RMI, or CORBA

calls

Server machine (business

Logic)DBMS-proprietary

protocolDatabase server


In the three-tier model, commands are sent to a "middle tier" of services, which then

send SQL statements to the database. The database processes the SQL statements and

sends the results back to the middle tier, which then sends them to the user. MIS

directors find the three-tier model very attractive because the middle tier makes it

possible to maintain control over access and the kinds of updates that can be made to

corporate data. Another advantage is that when there is a middle tier, the user can

employ an easy-to-use higher-level API which is translated by the middle tier into the

appropriate low-level calls. Finally, in many cases the three-tier architecture can

provide performance advantages.

Until now the middle tier has typically been written in languages such as C or C++,

which offer fast performance. However, with the introduction of optimizing compilers

that translate Java byte code into efficient machine-specific code, it is becoming

practical to implement the middle tier in Java. This is a big plus, making it possible to

take advantage of Java's robustness, multithreading, and security features. JDBC is

important to allow database access from a Java middle tier.



JDBC DRIVER TYPES

The JDBC drivers that we are aware of at this time fit into one of four categories:

JDBC-ODBC bridge plus ODBC driver

Native-API partly-Java driver

JDBC-Net pure Java driver

Native-protocol pure Java driver

JDBC-ODBC Bridge

If possible, use a Pure Java JDBC driver instead of the Bridge and an ODBC driver.

This completely eliminates the client configuration required by ODBC. It also

eliminates the potential that the Java VM could be corrupted by an error in the native

code brought in by the Bridge (that is, the Bridge native library, the ODBC driver

manager library, the ODBC driver library, and the database client library).

What Is the JDBC- ODBC Bridge?

The JDBC-ODBC Bridge is a JDBC driver, which implements JDBC operations by

translating them into ODBC operations. To ODBC it appears as a normal application

program. The Bridge implements JDBC for any database for which an ODBC driver

is available. The Bridge is implemented as the

Sun.jdbc.odbc Java package and contains a native library used to access ODBC. The

Bridge is a joint development of Innersole and Java Soft.

JDBC CONNECTIVITY

The JDBC provides database-independent connectivity between the J2EE platform

and a wide range of tabular data sources. JDBC technology allows an Application

Component Provider to:

Perform connection and authentication to a database server

Manager transactions

Move SQL statements to a database engine for preprocessing and execution

Execute stored procedures

Inspect and modify the results from Select statements

JAVA Server Pages



A JSP is similar in design and functionality to java servlet. It is called by the

client to provide a web service, the nature of which depends on the J2EE application.

However, a JSP differs from a servlet in the way in which the JSP is written. Java

Servlet is written using Java programming language and responses are encoded as an

output string object that is passed to the println () method. In contrast a JSP is written

in HTML, XML, or in the client’s format that is interspersed with scripting elements,

directives, and actions comprised of Java Programming language and JSP syntax.

There are three methods that are automatically called when the JSP is requested and

the JSP terminates normally. These are the jspInt () method, the jspDestroy () method,

and the service () method.

The jspInt () method is called first when the jsp is requested and is used to initialize

objects and variables that are used throughout the life of the JSP. The jspDestroy ()

method is automatically called when the JSP terminates normally. It isn’t called when

the JSP abruptly terminates. The service () method is automatically called and

retrieves connection to HTTP.

The jsp programs are executed by a JSP virtual machine that runs on a web server.

Therefore you will need to have access to a JSP virtual machine to run your JSP

program. One of the most popular JSP virtual machines is TOMCAT.

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:

SQL Level API

The designers felt that their main goal was to define a SQL interface for Java.

Although not the lowest database interface level possible, it is at a low enough level

for higher-level tools and APIs to be created. Conversely, it is at a high enough level

for application programmers to use it confidently. Attaining this goal allows for future



tool vendors to “generate” JDBC code and to hide many of JDBC’s complexities from

the end user.

SQL Conformance

SQL syntax varies as you move from database vendor to database vendor. In an effort

to support a wide variety of vendors, JDBC will allow any query statement to be

passed through it to the underlying database driver. This allows the connectivity

module to handle non-standard functionality in a manner that is suitable for its users.

JDBC must be implemental on top of common database interfaces

The JDBC SQL API must “sit” on top of other common SQL level APIs. This goal

allows JDBC to use existing ODBC level drivers by the use of a software interface.

This interface would translate JDBC calls to ODBC and vice versa.

Provide a Java interface that is consistent with the rest of the Java system

Because of Java’s acceptance in the user community thus far, the designers feel that

they should not stray from the current design of the core Java system.

Keep it simple

This goal probably appears in all software design goal listings. JDBC is no exception.

Sun felt that the design of JDBC should be very simple, allowing for only one method

of completing a task per mechanism. Allowing duplicate functionality only serves to

confuse the users of the API.

Use strong, static typing wherever possible

Strong typing allows for more error checking to be done at compile time; also,

less error appear at runtime.

Keep the common cases simple

Because more often than not, the usual SQL calls used by the programmer are

simple SELECT’s, INSERT’s, DELETE’s and UPDATE’s, these queries should be

simple to perform with JDBC. However, more complex SQL statements should also

be possible.

Finally we decided to proceed the implementation using Java Networking.

And for dynamically updating the cache table we go for MS Access database.



Java ha two things: a programming language and a platform.

Java is a high-level programming language that is all of the following

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.

MRITS-Department Of IT

Java Program

Compilers

Interpreter

My Program

25


Networking

TCP/IP stack

The TCP/IP stack is shorter than the OSI one:

TCP is a connection-oriented protocol; UDP (User Datagram Protocol) is a

connectionless protocol.

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.



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

The 32 bit address is usually written as 4 integers separated by dots.

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

A socket is a data structure maintained by the system to handle network connections.

A socket is created using the call socket. It returns an integer that is like a file

descriptor. In fact, under Windows, this handle can be used with Read File and Write

File functions.

#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.

JFree Chart

JFreeChart is a free 100% Java chart library that makes it easy for developers to

display professional quality charts in their applications. JFreeChart's extensive feature

set includes:

A consistent and well-documented API, supporting a wide range of chart types;

A flexible design that is easy to extend, and targets both server-side and client-side

applications;

Support for many output types, including Swing components, image files (including

PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG);

JFreeChart is "open source" or, more specifically, free software. It is distributed under

the terms of the GNU Lesser General Public Licence (LGPL), which permits use in

proprietary applications.

1. Map Visualizations

Charts showing values that relate to geographical areas. Some examples include: (a)

population density in each state of the United States, (b) income per capita for each

country in Europe, (c) life expectancy in each country of the world. The tasks in this

project include:

Sourcing freely redistributable vector outlines for the countries of the world,

states/provinces in particular countries (USA in particular, but also other areas);


http://www.gnu.org/philosophy/free-sw.html


Creating an appropriate dataset interface (plus default implementation), a rendered,

and integrating this with the existing XYPlot class in JFreeChart;

Testing, documenting, testing some more, documenting some more.

2. Time Series Chart Interactivity

Implement a new (to JFreeChart) feature for interactive time series charts --- to

display a separate control that shows a small version of ALL the time series data, with

a sliding "view" rectangle that allows you to select the subset of the time series data to

display in the main chart.

3. Dashboards

There is currently a lot of interest in dashboard displays. Create a flexible dashboard

mechanism that supports a subset of JFreeChart chart types (dials, pies, thermometers,

bars, and lines/time series) that can be delivered easily via both Java Web Start and an

applet.

4. Property Editors

The property editor mechanism in JFreeChart only handles a small subset of the

properties that can be set for charts. Extend (or reimplement) this mechanism to

provide greater end-user control over the appearance of the charts.

MY ECLIPSE

MyEclipse is a commercially available Java EE and AJAX IDE created and

maintained by the company Genuitec, a founding member of the Eclipse Foundation.

MyEclipse is built upon the Eclipse platform and integrates both proprietary

and open source solutions into the development environment.

MyEclipse has two primary versions (apart from the "Blue Edition" and

"MyEclipse Spring Editionhttp://en.wikipedia.org/wiki/MyEclipse - cite_note-3"



referred to below): a professional and a standard edition. The standard edition adds

database tools, a visual web designer, persistence

tools, Spring tools, Struts and JSF tooling, and a number of other features to the basic

Eclipse Java Developer profile. It competes with the Web Tools Project, which is a

part of Eclipse itself, but MyEclipse is a separate project entirely and offers a different

feature set.

Most recently, MyEclipse has been made available via Pulse (ALM), a

provisioning tool that maintains Eclipse software profiles, including those that use

MyEclipse. Additionally, MyEclipse is offering a customized version for IBM

products, "MyEclipse Blue Edition, that adds specific support for Rational

Software and WebSphere development. Currently, MyEclipse Blue Edition is

available for Windows and Linux, though Mac is unsupported.

My Eclipse includes

Java EE support.

Web service support.

Project and project creation wizard.

Customizable library containers.

New Web services wizard.

Deploy web services web-app.

Service.xml file editior.

Java editor with JSR-181 annotaion support and code-assist.

WSDL editor.

Web services explorer.

Java hot swap debug support

Expanded database support for MS, SQL and Sybase.

Cross platform visual HTML editor and JSP designers.



3.2.1Hardware Requirements:

PROCESSOR : PENTIUM IV 2.6 GHz

RAM : 512 MB DD RAM

MONITOR : 15” COLOR

HARD DISK : 20 GB

FLOPPY DRIVE : 1.44 MB

CDDRIVE : LG 52X

KEYBOARD : STANDARD 102 KEYS

MOUSE : 3 BUTTONS

3.2.2Software Requirements:

Front End : Java, JFC (Swing)

Backend : MS-Access (Data Base)

Tools Used : Eclipse 3.3

Operating System: Windows XP/7

3.3 Content diagram of the project



3.4 Algorithms and flow chat

Priority-based Scheduling Algorithm:

Assume Q represents the set of SSs serving non-real time connections (i.e., nrtPS

or BE connections) and T is the set of TSs. Due to the feature of TDD that the UL

and DL operations can not be performed simultaneously, we can not schedule the

SS which UL transmission interval is overlapped with the target TS. For any TS, St,

let Ot be the set of SSs which UL transmission interval overlaps with that of St in Q.

Thus, the possible corresponding CS of St must be in Q−Ot. All SSs in Q−Ot are

considered as candidates of the CS for St. A scheduling algorithm, called Priority-

based Scheduling Algorithm (PSA), shown in Algorithm 1 is used to schedule a SS

with the highest priority as the CS. The priority of each candidate is decided

based on the scheduling factor (SF) defined as the ratio of the current requested

bandwidth (CR) to the current granted bandwidth (CG). The SS with higher SF has

more demand on the bandwidth. Thus,we give the higher priority to those SSs.

The highest priority is given to the SSs with zero CG. Non-real time connections

include nrtPS and BE connections. The nrtPS connections should have higher

priority than the BE connections because of the QoS requirements. The priority of

candidates of CSs is concluded from high to

low as: nrtPS with zero CG, BE with zero CG, nrtPS with non-zero CG and BE with

non-zero CG. If there are more than one SS with the highest priority, we select

one with the largest CR as the CS in order to decrease the probability of overflow.



Flow Chart



Conclusion:

Variable bit rate applications generate data in variant rates. It is very challenging for

SSs to predict the amount of arriving data precisely. Although the existing method

allows the SS to adjust the reserved bandwidth via risk of failing to satisfy the QoS

requirements. Moreover, the unused bandwidth occurs in the current frame cannot be

utilized by the existing bandwidth adjustment since the adjusted amount of bandwidth

can be applied as early as in the next coming frame. Our research does not change the

existing bandwidth reservation to ensure that the same QoS guaranteed services are

provided. We proposed bandwidth recycling to recycle the unused bandwidth once it

occurs. It allows the BS to schedule a complementary station for each transmission

stations. Each complementary station monitors the entire UL transmission interval of

its corresponding TS and standby for any opportunities to recycle the unused

bandwidth. Besides the naive priority-based scheduling algorithm, three additional

algorithms have been proposed to improve the recycling effectiveness. Our

mathematical and simulation results confirm that our scheme can not only improve

the throughput but also reduce the delay with negligible overhead and satisfy the QoS

requirements.



4.DESIGN

4.1 INTRODUCTION

Software design sits at the technical kernel of the software engineering process

and is applied regardless of the development paradigm and area of application. Design

is the first step in the development phase for any engineered product or system. The

designer’s goal is to produce a model or representation of an entity that will later be

built. Beginning, once system requirement have been specified and analyzed, system

design is the first of the three technical activities -design, code and test that is required

to build and verify software.

The importance can be stated with a single word “Quality”. Design is the place

where quality is fostered in software development. Design provides us with



representations of software that can assess for quality. Design is the only way that we

can accurately translate a customer’s view into a finished software product or system.

Software design serves as a foundation for all the software engineering steps that

follow. Without a strong design we risk building an unstable system – one that will be

difficult to test, one whose quality cannot be assessed until the last stage.

During design, progressive refinement of data structure, program structure,

and procedural details are developed reviewed and documented. System design can be

viewed from either technical or project management perspective. From the technical

point of view, design is comprised of four activities – architectural design, data

structure design, interface design and procedural design.

Design Characteristics:

There are many aspects to consider in the design of a piece of software. The

importance of each should reflect the goals the software is trying to achieve. Some of

these aspects are:

Compatibility - The software is able to operate with other products that are

designed for interoperability with another product. For example, a piece of

software may be backward-compatible with an older version of itself.

Extensibility - New capabilities can be added to the software without major

changes to the underlying architecture.

Fault-tolerance - The software is resistant to and able to recover from

component failure



Maintainability - The software can be restored to a specified condition within

a specified period of time. For example, antivirus software may include the

ability to periodically receive virus definition updates in order to maintain the

software's effectiveness.

Modularity - the resulting software comprises well defined, independent

components. That leads to better maintainability. The components could be

then implemented and tested in isolation before being integrated to form a

desired software system. This allows division of work in a software

development project.

Packaging - Printed material such as the box and manuals should match the

style designated for the target market and should enhance usability. All

compatibility information should be visible on the outside of the package. All

components

required for use should be included in the package or specified as a

requirement

on the outside of the package.

Reliability - The software is able to perform a required function under stated

conditions for a specified period of time.

Reusability - the modular components designed should capture the essence of

the functionality expected out of them and no more or less. This single-minded

purpose renders the components reusable wherever there are similar needs in

other designs.

Robustness - The software is able to operate under stress or tolerate

unpredictable or invalid input. For example, it can be designed with a

resilience to low memory conditions.



Security - The software is able to withstand hostile acts and influences.

Usability - The software user interface must be usable for its target

user/audience. Default values for the parameters must be chosen so that they

are a good choice for the majority of the users.

First process

Second Process

Third process


Apply the RREQ to Neighbor to Destination Node

Get the RREP from the neighbor or destination node

Destination node

Source Node

Source Node

Packet ,Bandwidth calculationCreation

Intermediate Node

Destination node

DATA

P1

P2

Packets

Pn

Pn+1


4.2 Data flow diagrams

Object Oriented Design:

Object –Oriented design is a strategy where system designers think in terms of

‘things’ instead of operations or functions. The existing system is made up of

interacting objects that maintains their own local state and provides operations on the

state information. An object oriented design process involves designing the objects

and relationships between these classes. When the design is realized as an executing

program, the required objects are created dynamically using class definitions.

An important advantage of an object-oriented approach is that it simplifies the

problem of making changes to the design. The reason for this is that object state

representation does not influence the design. Changing the internal details of objects

is unlikely to affect any other system objects. Furthermore, because objects are

loosely coupled, it is usually straightforward to introduce new objects without

significant effects on the rest of the system.

Unified Modeling Language:

The Unified Modeling Language is a standard language for writing software

blueprints. The UML may be used to Visualize, Specify, Construct and Document the

artifacts of a software-intensive system.


Node1

Node2

Node4

Node3

RREP

+

RREQ

RREQ

RREQRREP+


Learning to apply the UML effectively starts with forming a conceptual model

of the language, which requires learning three major elements, the UML’s basic

building blocks, the rules that dictate how to these building blocks may be put

together, and some common mechanisms that apply throughout the language.

The UML is only a language and so it is just one part of a software

development method. The UML is process independent, although optimally it should

be used in a process that is use case driven, architecture-centric, iterative and

incremental.

UML is the international standard notation for object-oriented analysis and

design. The Object Management Group defines it. The heart of object-oriented

problem solving is the construction of a model. The model abstracts the essential

details of the underlying problem from its usually complicated real world. Several

modeling tools are wrapped under the heading of the UML, which stands for Unified

Modeling Language

UML DIAGRAMS:

CLASS DIAGRAMS



Node1

i,m,value

initialize component()Action performed()

Node 2

length,cond

Node2 ser ()Initialize Component()

Node 3

message,time,d

Node3()Server()

Node 4

i,m,n,k,cond

Node4()Action Performed()



Use case

State chart



Sender

Packet Creation

Apply RREQ

Get RREP

Destination

Activity Diagram



Off Conzone node

Destination

ON Conzone Node

select the off conzone node and transmit the data

Select the Node

Input Data

Sequence Diagram



Source : (Source)

Network Formation

Message Tranformation

RREQ

RREP

Message transfer to the RREP node

Collaboration Diagram

Source 1: RREQ

2: RREP

Network Formation

3: Message transfer to the RREP node

Message Transformation



Component Diagram

Network formation

Conzone Discovery

Message transformation

Modules:1. Bandwidth utilization Module:

Bandwidth utilization improvements have been proposed in the literature. In, a dynamic resource reservation mechanism is proposed. It can dynamically change the amount of reserved resource depending on the actual number of active connections. The investigation of dynamic bandwidth reservation for hybrid networks is presented in. Evaluated the performance and effectiveness for the hybrid network, and proposed efficient methods to ensure optimum reservation and utilization of bandwidth while minimizing signal blocking probability and signaling cost. In, the enhanced the system throughput by using concurrent transmission in mesh mode

2. Packet creation Module:In this module we split the Data in to N number of Fixed size packet with Maximum length of 48 Characters.

3. Bandwidth recycling Module:



The complementary station (CS). Waits for the possible opportunities to recycle the unused bandwidth of its corresponding TS in this frame. The CS information scheduled by the BS is resided in a list, called complementary list (CL). The CL includes the mapping relation between each pair of pre-assigned C and TS. 4. QoS guaranteed services ModuleIt is different from the bandwidth adjustment in which the adjusted bandwidth is enforced as early as in the next coming frame. Moreover, the unused bandwidth is likely to be released temporarily (i.e., only in the current frame) and the existing bandwidth reservation does not change. Therefore, our scheme improves the overall throughput while providing the same QoS guaranteed services.

5. Traffic and Packet Performance:The Packet mean data rate of each application but make the mean packet size randomly selected from 512 to 1024 bytes. Thus, the mean packet arrive rate can be determined based on the corresponding mean packet size. As mentioned earlier, the size of each packet is modeled as Poisson distributionAnd the packet arrival rate is modeled as exponential distribution.The other factor that may affect the performance of bandwidth recycling is the probability of the RM to be received by the CS successfully.4.5 Conclusion

The System Design describes desired features and operations in detail, including screen layouts, business rules, process diagrams, pseudo code and other documentation.Logical design:

The logical design of a system pertains to an abstract representation of the data flows, inputs and outputs of the system. This is often conducted via modeling, using an over-abstract of the actual system.Physical design: The physical design relates to the actual input and output processes of the system. This is laid down in terms of how data is input into a system, how it is verified/ authenticated, how it is processed, and how it is displayed as output.



High Level designs include UML diagrams and Low level diagrams include

Data Flow Diagrams.

A high-level design (HLD) provides an overview of a solution, platform,

system, product, service, or process.

Low Level Design (LLD) is like detailing the HLD. It defines the actual logic

for each and every component of the system.

This Software design is a process of problem-solving and planning for a software solution. After the purpose and specifications of software are determined, software developers will design or employ designers to develop a plan for a solution. It includes low-level component and algorithm implementation issues as well as the architectural view.

Hence it is necessary to take all the precautionary measures in this phase before developing the project.


http://en.wikipedia.org/wiki/Software_architecture

http://en.wikipedia.org/wiki/Algorithm

http://en.wikipedia.org/wiki/Designer

http://en.wikipedia.org/wiki/Design

http://en.wikipedia.org/wiki/Software_developer

http://en.wikipedia.org/wiki/Software


5. IMPLEMENTATION AND RESULTS

5.1. INTRODUCTION

In the implementation phase, the team builds the components either from

scratch or by composition. Given the architecture document from the design phase

and the requirement document from the analysis phase, the team should build exactly

what has been requested, though there is still room for innovation and flexibility. For

example, a component may be narrowly designed for this particular system, or the

component may be made more general to satisfy a reusability guideline

The Implementation phase of the SDLC consists of the Source Code of the

project. In computer science, source code is any collection of statements or

declarations written in some human-readable computer programming language.

Source code is the means most often used by programmers to specify the actions to be

performed by a computer.

In computer science, source code is any collection of statements or

declarations written in some human-readable computer programming language.

Source code is the means most often used by programmers to specify the actions to be

performed by a computer.

Moderately complex software customarily requires the compilation or

assembly of several, sometimes dozens or even hundreds, of different source code

files. In these cases, instructions for compilations, such as a Make file, are included

with the source code. These describe the relationships among the source code files,

and contain information about how they are to be compiled.

The revision control system is another tool frequently used by developers for

source code maintenance.



Implementation is the stage of the project when the theoretical design is turned out into a working system. Thus it can be considered to be the most critical stage in achieving a successful new system and in giving the user, confidence that the new system will work and be effective.

The implementation stage involves careful planning, investigation of the existing system and it’s constraints on implementation, designing of methods to achieve changeover and evaluation of changeover methods.

5.1.1 Concepts Implemented

Swings:

Swing is the primary Java GUI widget toolkit. It is part of Sun Microsystems'

Java Foundation Classes (JFC) — an API for providing a graphical user interface

(GUI) for Java programs. This was developed to provide a more sophisticated set of

GUI components than the earlier Abstract Window Toolkit. Swing provides a native

look and feel that emulates the look and feel of several platforms, and also supports a

pluggable look and feel that allows applications to have a look and feel unrelated to

the underlying platform.

The Internet Foundation Classes (IFC) were a graphics library for Java

originally developed by Netscape Communications Corporation and first released on

December 16, 1996. On April 2, 1997, Sun Microsystems and Netscape

Communications Corporation announced their intention to incorporate IFC with other

technologies to form the Java Foundation Classes.

Swing introduced a mechanism that allowed the look and feel of every

component in an application to be altered without making substantial changes to the

application code. The introduction of support for a pluggable look and feel allows

Swing components to emulate the appearance of native components while still

retaining the benefits of platform independence. This feature also makes it easy to

make an application written in Swing look very different from native programs if

desired.

Originally distributed as a separately downloadable library, Swing has been included

as part of the Java Standard Edition since release 1.2. The Swing classes and

components are contained in the javax.swing package hierarchy.


http://en.wikipedia.org/wiki/Java_package

http://download.oracle.com/javase/6/docs/api/javax/swing/package-summary.html

http://en.wikipedia.org/wiki/Java_Platform,_Standard_Edition

http://en.wikipedia.org/wiki/Pluggable_look_and_feel

http://en.wikipedia.org/wiki/Look_and_feel

http://en.wikipedia.org/wiki/Java_Foundation_Classes

http://en.wikipedia.org/wiki/Netscape_Communications_Corporation


http://en.wikipedia.org/wiki/Sun_Microsystems


http://en.wikipedia.org/wiki/Graphics_library

http://en.wikipedia.org/wiki/Internet_Foundation_Classes

http://en.wikipedia.org/wiki/Pluggable_look_and_feel

http://en.wikipedia.org/wiki/Look_and_feel

http://en.wikipedia.org/wiki/Abstract_Window_Toolkit

http://en.wikipedia.org/wiki/Software_component

http://en.wikipedia.org/wiki/Graphical_user_interface

http://en.wikipedia.org/wiki/Application_programming_interface

http://en.wikipedia.org/wiki/Java_Foundation_Classes

http://en.wikipedia.org/wiki/Sun_Microsystems

http://en.wikipedia.org/wiki/Widget_toolkit

http://en.wikipedia.org/wiki/GUI

http://en.wikipedia.org/wiki/Java_(programming_language)


Swing Architecture:

Swing is a platform-independent, Model-View-Controller GUI framework

for Java. It follows a single-threaded programming model. Swing is platform

independent both in terms of expression (Java) and implementation (Look-and-Feel).

Swing is a highly partitioned architecture, which allows for the "plugging" of

various custom implementations of specified framework interfaces: Users can provide

their own custom implementation(s) of these components to override the default

implementations. In general, Swing users can extend the framework by extending

existing (framework) classes and/or providing alternative implementations of core

components. This is a component-based framework. The distinction between objects

and components is a fairly subtle point: concisely, a component is a well-behaved

object with a known/specified characteristic pattern of behavior. Swing objects

asynchronously fire events, have "bound" properties, and respond to a well-known set

of commands (specific to the component.) Specifically, Swing components are Java

Beans components, compliant with the Java Beans Component Architecture

specifications.

Given the programmatic rendering model of the Swing framework, fine

control over the details of rendering of a component is possible in Swing. As a general

pattern, the visual representation of a Swing component is a composition of a standard

set of elements, such as a "border", "inset", decorations, etc. Typically, users will

programmatically customize a standard Swing component (such as a JTable) by

assigning specific Borders, Colors, Backgrounds, opacities, etc., as the properties of

that component. The core component will then use these properties (settings) to

determine the appropriate renderers to use in painting its various aspects. However, it

is also completely possible to create unique GUI controls with highly customized

visual representation.

Swing's heavy reliance on runtime mechanisms and indirect composition

patterns allows it to respond at runtime to fundamental changes in its settings. For

example, a Swing-based application can change its look and feel at runtime. Further,

users can provide their own look and feel implementation, which allows for uniform


http://en.wikipedia.org/wiki/Java_Beans

http://en.wikipedia.org/wiki/Java_Beans

http://en.wikipedia.org/wiki/Thread_(computing)

http://en.wikipedia.org/wiki/GUI

http://en.wikipedia.org/wiki/Model-View-Controller


changes in the look and feel of existing Swing applications without any programmatic

change to the application code.

Lightweight UI

Swing's configurability is a result of a choice not to use the native host OS's

GUI controls for displaying itself. Swing "paints" its controls programmatically

through the use of Java 2D APIs, rather than calling into a native user interface

toolkit. Thus, a Swing component does not have a corresponding native OS GUI

component, and is free to render itself in any way that is possible with the underlying

graphics APIs.

However, at its core every Swing component relies on an AWT container,

since (Swing's) JComponent extends (AWT's) Container. This allows Swing to plug

into the host OS's GUI management framework, including the crucial device/screen

mappings and user interactions, such as key presses or mouse movements. Swing

simply "transposes" its own (OS agnostic) semantics over the underlying (OS

specific) components. So, for example, every Swing component paints its rendition on

the graphic device in response to a call to component.paint(), which is defined in

(AWT) Container. But unlike AWT components, which delegated the painting to their

OS-native "heavyweight" widget, Swing components are responsible for their own

rendering.

This transposition and decoupling is not merely visual, and extends to Swing's

management and application of its own OS-independent semantics for events fired

within its component containment hierarchies. Generally speaking, the Swing

Architecture delegates the task of mapping the various flavors of OS GUI semantics

onto a simple, but generalized, pattern to the AWT container. Building on that

generalized platform, it establishes its own rich and complex GUI semantics in the

form of the JComponent model.

Loosely-Coupled and MVC

The Swing library makes heavy use of the Model/View/Controller software

design pattern, which conceptually decouples the data being viewed from the user


http://en.wikipedia.org/wiki/Design_pattern_(computer_science)

http://en.wikipedia.org/wiki/Model-view-controller

http://download.oracle.com/javase/6/docs/api/javax/swing/JComponent.html




interface controls through which it is viewed. Because of this, most Swing

components have associated models (which are specified in terms of Java interfaces),

and the programmer can use various default implementations or provide their own.

The framework provides default implementations of model interfaces for all of its

concrete components. The typical use of the Swing framework does not require the

creation of custom models, as the framework provides a set of default

implementations that are transparently, by default, associated with the corresponding

JComponent child class in the Swing library. In general, only complex components,

such as tables, trees and sometimes lists, may require the custom model

implementations around the application-specific data structures. To get a good sense

of the potential that the Swing architecture makes possible, consider the hypothetical

situation where custom models for tables and lists are wrappers over DAO and/or EJB

services..

Typically, Swing component model objects are responsible for providing a

concise interface defining events fired, and accessible properties for the (conceptual)

data model for use by the associated JComponent. Given that the overall MVC pattern

is a loosely-coupled collaborative object relationship pattern, the model provides the

programmatic means for attaching event listeners to the data model object. Typically,

these events are model centric (ex: a "row inserted" event in a table model) and are

mapped by the JComponent specialization into a meaningful event for the GUI

component.

For example, the JTable has a model called Table Model that describes an

interface for how a table would access tabular data. A default implementation of this

operates on a two-dimensional array.The view component of a Swing JComponent is

the object used to graphically "represent" the conceptual GUI control. A distinction of

Swing, as a GUI framework, is in its reliance on programmatically-rendered GUI


http://en.wikipedia.org/wiki/Array_data_structure

http://download.oracle.com/javase/6/docs/api/javax/swing/table/TableModel.html

http://download.oracle.com/javase/6/docs/api/javax/swing/JTable.html

http://en.wikipedia.org/wiki/Ejb

http://en.wikipedia.org/wiki/Data_Access_Objects


http://en.wikipedia.org/wiki/Interface_(computer_science)


controls (as opposed to the use of the native host OS's GUI controls). Prior to Java 6

Update 10, this distinction was a source of complications when mixing AWT controls,

which use native controls, with Swing controls in a GUI (see Mixing AWT and Swing

components).

Finally, in terms of visual composition and management, Swing favors relative

layouts (which specify the positional relationships between components) as opposed

to absolute layouts (which specify the exact location and size of components). This

bias towards "fluid"' visual ordering is due to its origins in the applet operating

environment that framed the design and development of the original Java GUI toolkit.

(Conceptually, this view of the layout management is quite similar to that which

informs the rendering of HTML content in browsers, and addresses the same set of

concerns that motivated the former.)

AWT and Swing class hierarchy

Since early versions of Java, a portion of the Abstract Window Toolkit (AWT)

has provided platform-independent APIs for user interface components. In AWT,

each component is rendered and controlled by a native peer component specific to the

underlying windowing system. By contrast, Swing components are often described as

lightweight because they do not require allocation of native resources in the operating

system's windowing toolkit. The AWT components are referred to as heavyweight

components.

Much of the Swing API is generally a complementary extension of the AWT

rather than a direct replacement. In fact, every Swing lightweight interface ultimately

exists within an AWT heavyweight component because all of the top-level

components in Swing (JApplet, JDialog, JFrame, and JWindow) extend an AWT top-

level container. Prior to Java 6 Update 10, the use of both lightweight and

heavyweight components within the same window was generally discouraged due to

Z-order incompatibilities. However, later versions of Java have fixed these issues, and

both Swing and AWT components can now be used in one GUI without Z-order

issues. The core rendering functionality used by Swing to draw its lightweight

components is provided by Java 2D, another part of JFC.


http://en.wikipedia.org/wiki/Java_2D

http://en.wikipedia.org/wiki/Z-order

http://en.wikipedia.org/wiki/Java_version_history#Java_SE_6_Update_10

http://download.oracle.com/javase/6/docs/api/javax/swing/JWindow.html

http://download.oracle.com/javase/6/docs/api/javax/swing/JFrame.html

http://download.oracle.com/javase/6/docs/api/javax/swing/JDialog.html

http://download.oracle.com/javase/6/docs/api/javax/swing/JApplet.html


http://en.wikipedia.org/wiki/Java_applet

http://en.wikipedia.org/wiki/Layout_manager

http://en.wikipedia.org/wiki/Layout_manager

http://en.wikipedia.org/wiki/Abstract_Window_Toolkit#Mixing_AWT_and_Swing_components

http://en.wikipedia.org/wiki/Abstract_Window_Toolkit#Mixing_AWT_and_Swing_components




Main logic: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();jTextArea1.append("Destination Address

"+s+"\n");if(s==11) {

long sender_time=dis.readLong();

int length=dis.readInt();

rr=new String[length];while(length>0){

rr[count]=dis.readUTF(); System.out.println("the

received output is"+rr[count]); jTextArea2.append("\n\nPacket

" + "-->\n***********\n"+rr[count]);

length--; count++;} long d=dis.readLong(); double flen=(double)d/1024; long

receiver_time=System.currentTimeMillis(); double delay=((double)

(receiver_time-sender_time)/1000); jTextArea1.append("delay "

+delay+ "\n"); double delay1=((double)

(receiver_time-sender_time)/1000); jTextArea1.append("Bit rate "

+flen/delay1+ "\n"); String sd=""+flen;



jTextArea1.append(("file length"+" "+sd.substring(0,4)+" KB \n"));

double Bandwidth=(double)flen/delay;

String as=""+Bandwidth;

jTextArea1.append("Bandwidth"+" "+as.substring(0,5)+"kbps \n");

} else

{if(s==33) {

jTextArea1.append("MESSAGE SEND TO NODE3 \n");String

pro="Recyclic RREQ to NODE3";

JOptionPane.showMessageDialog(this,pro);

Thread.sleep(500);

String pro1="Recyclic RREP From NODE3";

JOptionPane.showMessageDialog(this,pro1); } else {

jTextArea1.append("MESSAGE SEND TO NODE2 \n");

String pro="Recyclic RREQ to NODE2";

JOptionPane.showMessageDialog(this,pro);

Thread.sleep(500);

String pro1="Recyclic RREP From NODE2";

JOptionPane.showMessageDialog(this,pro1);

}long

sender_time=dis.readLong();int length=dis.readInt();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);



5.2 Sample output screens





5.4 Conclusion

Towards the end of implementation phase, the desired result of the project takes more

and more shape: we integrate, test, and commission last sub-parts. The end product or

service is essentially put together. Bandwidth recycling to recycle the unused

bandwidth once it occurs. It allows the BS to schedule a complementary station for

each transmission stations. Each complementary station monitors the entire UL

transmission interval of its corresponding TS and standby for any opportunities to

recycle the unused bandwidth. Besides the naive priority-based scheduling algorithm,

three additional algorithms have been proposed to improve the recycling

effectiveness. Our mathematical and simulation results confirm that our scheme can

not only improve the throughput but also reduce the delay with negligible overhead

and satisfy the QoS requirements.



TESTING AND VALIDATION

6.1 INTRODUCTION

Software testing is a critical element of software quality assurance and

represents the ultimate review of specification, design and coding. In fact, testing is

the one step in the software engineering process that could be viewed as destructive

rather than constructive?

A strategy for software testing integrates software test case design methods

into a well-planned series of steps that result in the successful construction of

software. Testing is the set of activities that can be planned in advance and conducted

systematically. The underlying motivation of program testing is to affirm software

quality with methods that can economically and effectively apply to both strategic to

both large and small-scale systems

TESTING STRATEGIES:

Unit Testing

Unit testing focuses verification effort on the smallest unit of software design,

the module. The unit testing we have is white box oriented and some modules the

steps are conducted in parallel.

1. WHITE BOX TESTING

This type of testing ensures that

1 All independent paths have been exercised at least once

2 All logical decisions have been exercised on their true and false sides

3 All loops are executed at their boundaries and within their operational bounds

4 All internal data structures have been exercised to assure their validity.

To follow the concept of white box testing we have tested each form .we have created

independently to verify that Data flow is correct, All conditions are exercised to check

their validity, All loops are executed on their boundaries.



2. CONDITIONAL TESTING

In this part of the testing each of the conditions were tested to both true and

false aspects. And all the resulting paths were tested. So that each path that may be

generate on particular condition is traced to uncover any possible errors.

3. DATA FLOW TESTING

This type of testing selects the path of the program according to the location of

definition and use of variables. This kind of testing was used only when some local

variable were declared. The definition-use chain method was used in this type of

testing. These were particularly useful in nested statements.

4. LOOP TESTING

In this type of testing all the loops are tested to all the limits possible. The

following exercise was adopted for all loops:

1 All the loops were tested at their limits, just above them and just below them.

2 All the loops were skipped at least once.

3 For nested loops test the inner most loop first and then work outwards.

4 For concatenated loops the values of dependent loops were set with the help of

connected loop.

5 Unstructured loops were resolved into nested loops or concatenated loops and

tested as above.

Each unit has been separately tested by the development team itself and all the input

have been validated.



Testing-purpose

The purpose of testing is to assess product quality. It helps to strengthen and

stabilize the architecture early in the development cycle. We can verify through

testing, the various interactions, integration of components and the requirements

which were implemented. It provides timely feedback to resolve the quality issues, in

a timely and cost effective manner. The test workflow involves the following:

Verifying the interactions of components.

Verifying the proper integration of components.

Verifying that all requirements have been implemented correctly.

Identifying and ensuring that all discovered defects are addressed before

the software is deployed.


UNIT TESTING

MODULE TESTING

SUB-SYSTEM TESING

SYSTEM TESTING

ACCEPTANCE TESTING

Component Testing

Integration Testing

User Testing


(a) Black Box Testing:

The functionality of the application has been tested in various modules of the

application.

The following are Black Box Tested:

1. Data base communication for request and response.

2. The status at each stage of the PASSPORT processing.

3. The security of the system from the perspective of administrator and end user.

4. Image handling storing and retrieval of data.

(b) White Box Testing:

1. Every module in the application has been tested to verify that each and every

line of statement either part of execute at least once.

2. This was done by providing data that were null, invalid format inconsistent

length as well as data types.

(c)String Testing:

The strings in the applications were tested for nulls , invalid length , alpha

numeric inputs in the enrollment and pre-visa modules. This isolated errors that

pertain to type casting, length and storage.

Here we are testing for entry of a null character, if the entry is null then the output is

given as a failure, and to continue to other field or form then a valid string is to be

entered only then the process continues.

Here we are checking for a valid user id and valid password, where if a user id

of less

Than 4 characters is entered and if a password of less than 5 characters is entered then

Messages as “Invalid ..! enter id more than 4 charechters and password more than 5

charechters.” is given as output.



(d) Input acceptance Testing:

Data with irregular formats, consistency were provided to check the input

fields within the modules exceptions were handled to handle input and output

operations on different columns and fields.

Unit Testing:

The system with its modules when individually tested to see if each module

executed independently. The modules pertaining to offer pre-visa conformation of

enrollment and visa processing was tested using static data and found to execute as

per the SRS.

The following were checked in the process

1. Communication with the database within the module.

2. Flow of data and control verifying tab orders.

3. Updating of tables from a single module which are industry used by other

modules.

4. Invalid data provided intentionally to remove uncertain or unaccepted errors.

5. Exceptional handling was done to remove the above errors.

Here in unit testing the login id and password are taken from the database and

also the retrieved data is checked for its correctness and if they are correctly validated

then the control passes on to next action else it doesn’t continue until valid text is got.

Integrated Testing:

All the modules were integrated from a home page which then provided links

for connectivity to other modules.

The links communicated with the corresponding modules and was found to

execute as per the SRS. The following were tested:

The control of transfer between the web pages.

Flow of data between the various modules.



Updations to the databases common to the module

Executions of queries, maintenance sessions and global data.

6.2 DESIGN OF TEST CASES AND SCENARIOS

Test cases for a Browse button

After clicking on upload button file selection window should open

After clicking on the cancel button of selection window that window should

closed

In between uploading process click on upload button again( It should be

disable)

If file size in big proper message should be display

Check for the file type which going to upload

6.3 Conclusion



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.

With the various test cases we can determine the possible errors and rectify them. A test is said to be successful if it detects errors and corrects them.

CONCLUSION



Variable bit rate applications generate data in variant rates. It is very challenging

for SSs to predict the amount of arriving data precisely. Although the existing

method allows the SS to adjust the reserved bandwidth bandwidth requests in

each frame, it cannot avoid the risk of failing to satisfy the QoS requirements.

Moreover, the unused bandwidth occurs in the current frame cannot be utilized by

the existing bandwidth adjustment since the adjusted amount of bandwidth can

be applied as early as in the next coming frame. Our research does not change

the existing bandwidth reservation to ensure that the same QoS guaranteed

services are provided. We proposed bandwidth recycling to recycle the unused

bandwidth once it occurs. It allows the BS to schedule a complementary station

for each transmission stations. Each complementary station monitors the entire

UL transmission interval of its corresponding TS and standby for any opportunities

to recycle the unused bandwidth. Besides the naive priority-based scheduling

algorithm, three additional algorithms have been proposed to improve the

recycling effectiveness. Our mathematical and simulation results confirm that our

scheme can not only improve the throughput but also reduce the delay with

negligible overhead and satisfy the QoS requirements.



FUTURE ENHANCEMENTAs our investigation, one of the factors causing recycling failures is that the CS

does not have data to transmit while receiving a RM. To alleviate this factor, we

propose to schedule SSs which have rejected BRs in the last frame because it can

ensure that the SS scheduled as CS has data to recycle the unused bandwidth.

This scheduling algorithm is called Rejected Bandwidth Requests First Algorithm

(RBRFA). It is worth to notice that the RBRFA is only suitable to heavily loaded

networks with rejected BRs sent from non-real time connections (i.e., nrtPS or BE).

Notice that only rejected BRs sent in the last frame are considered in the RBRFA

for scheduling the current frame. The RBRFA is summarized .The BS grants or

rejects BRs based on its available resource and scheduling policy. In RBRFA, if the

BSgrants partially amount of bandwidth requested by a BR, then this BR is also

considered as a rejected BR. Similar Ot represents the set of SSs which

transmission period overlaps with the TS, St, in QR. All SSs in Qt are considered as

possible CSs of St. A rejected BR shows that the SS must have extra data to be

transmitted in the next frame and no bandwidth is allocated for these data. The

RBRFA schedules those SSs as CSs on the CL, so the probability to recycle the

unused bandwidth while the CS receives the RM is increased. The other factor

that may affect the performance of bandwidth recycling is the probability of the

RM to be received by the CS successfully. To increase this probability, a

scheduling algorithm, named history-Based Scheduling Algorithm (HBA), is

proposed. The HBA is summarized . For each TS, the BS maintains a list, called

Black List (BL). The basic CID of a CS is recorded in the BL of the TS if this CS

cannot receive RMs sent from the TS. According to our protocol, the CS transmits

data or pad the rest of transmission interval if a RM is received. The BS considers

that a CS cannot receive the RM from its corresponding TS if the BS does not

receive either data or padding information from the CS. When the BS schedules

the CS of each TS in future frames, the BS only schedules a SS which is not on the

BL of the TS as the CS. After collecting enough history, the BL of each TS should

contains the basic CID of all SSs which cannot receive the RM sent from the TS.

By eliminating those SS, the BS should have high probability to schedule a CS

which can receive the RM successfully. Therefore, BAcan increase the probability

of scheduling a SS which is able to receive the RM as the CS.

To support the mobility, the BL of each TS should be updated periodically.

Moreover, the BS changes the UL burst profile of the SS when it cannot listen to

the SS clearly. There are two possible reasons which may make the BS receive

signals unclearly: 1) the SS has moved to another location. 2) the background

noise is strong enough to interfere the data transmissions. Sincethose two factors

may also affect the recipient of RMs, therefore, the BL containing this SS should



be updated as well. The two algorithms described above focus on mitigating each

factor that may cause the failure of recycling. The RBRFA increases the probability

that the CS has data to transmit while receiving the RM. The HBA increases the

probability that the CS receives the RM. However, none of them can alleviate both

factors at the same time. By taking the advantages of both RBRFA and HBA, an

algorithm called Hybrid Scheduling Algorithm (HSA) is proposed. HSA can increase

not only the probability of CSs to transmit data while receiving the RM but also

the probability of CSs to receive the RM. The detail of Has is summarized


Documents

New Microsoft Word Document(1)