Download paper

Improving Active Packet Loss Measurement Computer Science Essay

Measurement and appraisal of package loss features are disputing due to the comparatively rare happening and typically short continuance of package loss episodes. While active investigation tools are normally used to mensurate packet loss on end-to-end waies, there has been small analysis of the truth of these tools. The aim of our survey is to understand how to mensurate package loss episodes accurately with end-to-end investigations. Surveies show that the standard Poisson-modulated end-to-end measuring of package loss truth has to be improved.

Therefore, we introduce a new algorithm for package loss measuring that is designed to get the better of the lacks in standard Poisson-based tools. Specifically, our method entails investigation experiments that follow a geometric distribution to enable more accurate measurings than standard Poisson probing and other traditional package loss measuring tools.

We besides find the transportation rate. We evaluate the capablenesss of our methodological analysis by experimentation by developing and implementing a paradigm tool, called BADABING. BADABING studies loss features are far more accurately than traditional loss measuring tools.

Measuring and analysing web traffic kineticss between terminal hosts has provided the foundation for the development of many different web protocols and systems. Of peculiar importance is under-standing package loss behaviour since loss can hold a important impact on the public presentation of both TCP- and UDP-based applications. Despite attempts of web applied scientists and operators to restrict loss, it will likely ne’er be eliminated due to the intrinsic kineticss and scaling belongingss of traffic in package switched web.

Top Experts
Verified expert
4.9 (247)
Prof. Clara
Verified expert
5 (345)
Doctor Jennifer
Verified expert
5 (893)
hire verified expert

Network operators have the ability to passively supervise nodes within their web for package loss on routers utilizing SNMP. End-to-end active measurings utilizing investigations provide an every bit valuable position since they indicate the conditions that application traffic is sing on those waies.

Our survey involves the empirical rating of our new loss measuring methodological analysis. To this terminal, we developed a one-way active measuring tool called BADABING. BADABING sends fixed-size investigations at specified intervals from one measuring host to a join forcesing mark host. The mark system collects the investigation packages and studies the loss features after a specified period of clip. We besides compare BADABING with a standard tool for loss measuring that emits investigation packages at Poisson intervals. The consequences show that our tool studies loss episode estimates much more accurately for the same figure of investigations. We besides show that BADABING estimations converge to the implicit in loss episode frequence and continuance features.

The most normally used tools for examining end-to-end waies to mensurate the package loss resemble the omnipresent PING public-service corporation. PING-like tools send investigation packages ( e.g. , ICMP echo packages ) to a mark host at fixed intervals. Loss is inferred by the transmitter if the response packages expected from the mark host are non received within a specified clip period. Generally speech production, an active measuring attack is debatable because of the distinct sampling nature of the investigation procedure. Therefore, the truth of the ensuing measurings depends both on the features and reading of the trying procedure every bit good as the features of the implicit in loss procedure.

The end of our survey is to understand how to accurately mensurate loss features on end-to-end waies with investigations. We are interested in two specific features of package loss: loss episode frequence, and loss episode continuance. Our survey consists of three parts: ( I ) empirical rating of the presently predominating attack, ( two ) development of appraisal techniques that are based on fresh experimental design, fresh examining techniques, and simple proof trials, and ( three ) empirical rating of this new methodological analysis.

The most of import deduction of these consequences is that there is now a methodological analysis and tool available for wide-area surveies of package loss features that enables research workers to understand and stipulate the tradeoffs between truth and impact. Furthermore, the tool is self-calibrating in the sense that it can describe when estimations are hapless. Practical applications could include its usage for way choice in peer-to-peer sheathing webs and as a tool for web operators to supervise specific sections of their substructures.

Existing System:

In the Existing traditional package loss measuring tools, the truth of the package loss measuring has to be improved.

Several surveies include the usage of loss measurings to gauge package loss, such as Poisson modulated tools which can be rather inaccurate.

Proposed System:

The intent of our survey is to understand how to mensurate end-to-end package loss features accurately.

The end of our survey is to understand how to accurately mensurate loss features on end-to-end waies with investigations.

Specifically, our method entails investigation experiments that follow a geometric attack to better the truth of the package loss measuring.

Faculties of the Undertaking:

Packet Separation

Planing the Queue

Package Receiver

User Interface Design

Packet Loss Calculation

Module Description:

Packet Separation:

In this faculty we have to divide the input informations into packages. These packages are so sent to the Queue.

Planing the Queue:

The Queue is designed in order to make the package loss. The waiting line receives the packages from the Sender, creates the package loss and so sends the staying packages to the Receiver.

Package Receiver:

The Packet Receiver is used to have the packages from the Queue after the package loss. Then the receiving system displays the standard packages from the Queue.

User Interface Design:

In this faculty we design the user interface for Sender, Queue, Receiver and Result exposing window. These Windowss are designed in order to expose all the procedures in this undertaking.

Packet Loss Calculation:

The computations to happen the package loss are done in this faculty. Thus we are developing the tool to happen the package loss.

System Requirements:


Processor: Pentium IV 2.6 GHz

Random-access memory: 512 MB

Proctor: 15 ”

Difficult Disk: 20 GB

CD-Drive: 52X

Key Board: Standard 102 Keys


Front End: Java, Swings

Tools Used: JFrameBuilder

Operating System: Windows XP

System Architecture:




Data Flow Diagram:




( For Packets loss )


Packages after loss

Use Case Diagram:

A Use-Case theoretical account can be instrumental in undertaking development, planning, and certification of system demands. A Use-Case is an interaction between users and a system. It captures the end of the users and the duty of the system to its users. A Use-case theoretical account describes the utilizations of the system and shows the happenings of events that can be performed.

A Use instance is shown as oval incorporating the name of the usage instance. The name of the usage instance can be placed below or inside the oval.

An Actor is shown as a category rectangle with the label & lt ; & lt ; histrion & gt ; & gt ; or the label and a stick figure or merely stick figure with name of the histrion.


& lt ; & lt ; Actor & gt ; & gt ;




Sequence Diagram:

The sequence diagram is an interaction diagram that emphasizes the clip ordination of messages for patterning a existent clip system. Diagrammatically, a sequence diagram is a tabular array that shows objects arranged along the X axis and messages, ordered in increasing clip, along the Y axis. Sequence Diagram consists of objects, links, line of life, focal point of control, and messages.

Object: Objects are typically named or anon. cases of category. But may besides stand for cases of other things such as constituents, coaction and nodes.

Link: A nexus is a semantic connexion among objects i.e. , an object of an association is called as a nexus.

Line of life: A line of life is perpendicular dotted line that represents the life-time of an object.

Focus of Control: A Focus of Control is tall, thin rectangle that shows the period of clip during which an object is executing an action.

Messages: A message is a specification of a communicating between objects that conveys the information with the outlook that the activity will result.

Class Diagram:

A category diagram is a type of inactive construction diagram that describes the construction of a system by demoing the system ‘s categories, their properties, and the relationships between the categories.

Class: Class is a description of a set of objects that portion the same properties, operations, relationships and semantics. A category implements one or more interfaces.

Interface: Interface is a aggregation of operations that specify a service of a category or constituent. An interface describes the externally seeable behaviour of that component. An interface might stand for the complete behaviour of a category or constituent.

Collaboration: Collaboration defines an interaction and is a society of functions and other elements that work together to supply some concerted behaviour. So coactions have structural every bit good as behavioural, dimensions. These coactions represent the execution of forms that make up a system.

Relationships such as

Dependence: Dependence is a semantic relationship between two things in which a alteration to one thing may impact the semantics of the other thing.

Generalization: A generalisation is a specialisation / generalisation relationship in which objects of the specialised component ( kid ) are substitutable for objects of the generalised component ( parent ) .

Association: An association is a structural relationship that describes a set of links, a nexus being a connexion among objects. Aggregation is a particular sort of association, stand foring a structural relationship between a whole and its parts.

Class Name



Activity Diagram:

An activity diagram shows the flow from activity to activity. The activity diagram emphasizes the dynamic position of a system. It consists of activity provinces, action provinces, passage, and object.

Activity State: An activity states is a sort of provinces in activity diagram ; it shows an on-going non-atomic executing within a province machine. An activity provinces can be farther decomposed.

Action State: An action provinces are provinces of the system, each stand foring the executing of an action. An action provinces ca n’t be farther decomposed.

Passage: A passage specifies the way from one action or activity province to the following action or activity province. The passage is rendered as a simple directed line.

Object: An object is a concrete manifestation of an abstraction ; an entity with a well defined boundary and individuality that encapsulates province and behaviour ; an case of a category. Objects may be involved in the flow of control associated with an activity diagram.


Java is an object-oriented multithread scheduling linguistic communications.It is designed to be little, simple and portable across different platforms every bit good as operating systems.

Features of Java:

Platform Independence:

The Write-Once-Run-Anywhere ideal has non been achieved ( tuning for different platforms normally required ) , but closer than with other linguistic communications.

Object Oriented

Object oriented throughout – no coding outside of category definitions, including chief ( ) .

An extended category library available in the nucleus linguistic communication bundles.

Compiler/Interpreter Combo

Code is compiled to byte codifications that are interpreted by a Java practical machines ( JVM ) .

This provides portability to any machine for which a practical machine has been written.

The two stairss of digest and reading allow for extended codification checking and improved security.


Exception managing built-in, strong type checking ( that is, all informations must be declared an expressed type ) , local variables must be initialized.

Several characteristics of C & A ; C++ eliminated:

No memory pointersA

No preprocessor

Array index bound look intoing

Automatic Memory Management:

Automatic refuse aggregation – memory direction handled by JVM.


No memory arrows

Plans run inside the practical machine sandbox.

Array index bound look intoing

Code pathologies reduced by

Byte codification verifier – cheques categories after lading

Class stevedore – confines objects to alone namespaces. Prevents lading a hacked “ java.lang.SecurityManager ” category, for illustration.

Security director – determines what resources a category can entree such as reading and composing to the local disc.

Dynamic Binding:

The linking of informations and methods to where they are located is done at run-time.

New categories can be loaded while a plan is running. Associating is done on the fly.

Even if libraries are recompiled, there is no demand to recompile codification that uses categories in those libraries.

This differs from C++ , which uses inactive binding. This can ensue in fragile categories for instances where linked codification is changed and memory arrows so indicate to the incorrect references.

Good Performance

Interpretation of byte codifications slowed public presentation in early versions, but advanced practical machines with adaptative and just-in-time digest and other techniques now typically supply public presentation up to 50 % to 100 % the velocity of C++ plans.


Lightweight procedures, called togss, can easy be spun off to execute parallel processing.

Can take advantage of multiprocessors where available

Great for multimedia shows.

Net Beans:

Net Beans A Java-based development environment ( IDE ) and platform originally developed by Sun. It includes user interface maps, beginning codification editor, GUI editor, version control every bit good as support for distributed applications ( CORBA, RMI, etc. ) and Web applications ( JSPs, servlets, etc. ) .

In 1999, Sun acquired NetBeans Developer from NetBeans and rebranded it as Forte for Java Community Edition ( Sun acquired Forte in 1999 ) . In 2000, Sun made the NetBeans IDE unfastened beginning.

1. Graphical user interface: The major demand of today ‘s developers is to hold a good User Interface for their users. They can supply whatever functionality they need but it ‘s the GUI that lets the user better know the being of that peculiar functionality and its easier for them to snap and choose than type something on a black drilling screen. Thus, today ‘s developers need IDE ‘s such as netbeans that develop ready made Windowss signifiers with all the needed buttons, labels, text boxes and like that can be tailor made for the plan in inquiry.

2. Database Integration: Database based plan developers know how difficult it is to interface your back-end database to your front-end plan. This is where netbeans packs the clout by supplying you a CRUD ( create, Read, Update, Delete ) application shell.

J2EE ( Java 2 Enterprise Edition ) :

Today, more and more developers want to compose distributed transactional applications for the endeavor and leverage the velocity, security, and dependability of server-side engineering. If you are already working in this country, you know that in today ‘s fast-moving and demanding universe of e-commerce and information engineering, endeavor applications have to be designed, built, and produced for less money, with greater velocity, and with fewer resources than of all time before.

To cut down costs and fast-track endeavor application design and development, the Java 2 Platform, Enterprise Edition ( J2EE ) engineering provides a component-based attack to the design, development, assembly, and deployment of endeavor applications. The J2EE platform offers a multi tiered distributed application theoretical account, the ability to recycle constituents, integrated Extensile Markup Language ( XML ) -based informations interchange, a incorporate security theoretical account, and flexible dealing control. Not merely can you present advanced client solutions to market faster than of all time, but your platform-independent J2EE component-based solutions are non tied to the merchandises and application scheduling interfaces ( APIs ) of any one seller. Sellers and clients enjoy the freedom to take the merchandises and constituents that best meet their concern and technological demands.

Distributed Multi tiered Applications:

The J2EE platform uses a multi tiered distributed application theoretical account. Application logic is divided into constituents harmonizing to map, and the assorted application constituents that make up a J2EE application are installed on different machines depending on the grade in the multi tiered J2EE environment to which the application constituent belongs

J2EE Components:

Client-tier constituents run on the client machine.

Web-tier constituents run on the J2EE waiter.

Business-tier constituents run on the J2EE waiter.

Enterprise information system ( EIS ) -tier package runs on the EIS waiter.

J2EE multi tiered applications are by and large considered to be three-tiered applications because they are distributed over three different locations: client machines, the J2EE waiter machine, and the database or bequest machines at the back terminal. Three-tiered applications that run in this manner extend the standard two-tiered client and waiter theoretical account by puting a multithreaded application waiter between the client application and back-end storage.

J2EE applications are made up of constituents. A J2EE constituent is a self-contained functional package unit that is assembled into a J2EE application with its related categories and files and that communicates with other constituents. The J2EE specification defines the undermentioned J2EE constituents:

Application clients and applets are constituents that run on the Client.

Java Servlet and Java Server Pages ( JSP ) engineering Components are Web constituents that run on the waiter.

Enterprise JavaBeans ( EJB ) constituents ( enterprise beans ) are concern constituents that run on the waiter.

J2EE constituents are written in the Java scheduling linguistic communication and are compiled in the same manner as any plan in the linguistic communication. The difference between J2EE constituents and “ standard ” Java categories is that J2EE constituents are assembled into a J2EE application, verified to be good formed and in conformity with the J2EE specification, and deployed to production, where they are run and managed by the J2EE waiter.

Web Clients

A Web client consists of two parts: dynamic Web pages incorporating assorted types of markup linguistic communication ( HTML, XML, and so on ) , which are generated by Web constituents running in the Web grade, and a Web browser, which renders the pages received from the waiter.

A Web client is sometimes called a thin client. Thin clients normally do non make things like question databases, execute complex concern regulations, or connect to bequest applications. When you use a thin client, heavyweight operations like these are off-loaded to enterprise beans put to deathing on the J2EE waiter where they can leverage the security, velocity, services, and dependability of J2EE server-side engineerings.


Web constituents are the preferable API for making a Web client plan because no circuit boards or security policy files are needed on the client systems. Besides, Web constituents enable cleaner and more modular application design because they provide a manner to divide applications programming from Web page design. Forces involved in Web page design therefore do non necessitate to understand Java programming linguistic communication sentence structure to make their occupations.

Application Clients:

A J2EE application client runs on a client machine and provides a manner for users to manage undertakings that require a richer user interface than can be provided by a markup linguistic communication. It typically has a graphical user interface ( GUI ) created from Swinging or Abstract Window Toolkit ( AWT ) APIs, but a command-line interface is surely possible.

Application clients straight entree endeavor beans running in the concern grade. However, if application demands warrant it, a J2EE application client can open an HTTP connexion to set up communicating with a servlet running in the Web grade.

JavaBeans Component Architecture

The waiter and client grades might besides include constituents based on the JavaBeans component architecture ( JavaBeans constituent ) to pull off the informations flow between an application client or applet and constituents running on the J2EE waiter or between server constituents and a database. JavaBeans constituents are non considered J2EE constituents by the J2EE specification.

JavaBeans constituents have case variables and acquire and put methods for accessing the information in the case variables. JavaBeans constituents used in this manner are typically simple in design and execution, but should conform to the naming and design conventions outlined in the JavaBeans component architecture.

J2EE Server Communications

The client communicates with the concern grade running on the J2EE waiter either straight or, as in the instance of a client running in a browser, by traveling through JSP pages or servlets running in the Web grade.

J2EE application uses a thin browser-based client or thick application client. In make up one’s minding which one to utilize, should be cognizant of the tradeoffs between maintaining functionality on the client and stopping point to the user ( thick client ) and off-loading as much functionality as possible to the waiter ( thin client ) . The more functionality you off-load to the waiter, the easier it is to administer, deploy, and pull off the application ; nevertheless, maintaining more functionality on the client can do for a better perceived user experience.


Microsoft Open Database Connectivity ( ODBC ) is a standard scheduling interface for application developers and database systems suppliers. Before ODBC became a de facto criterion for Windows plans to interface with database systems, coders had to utilize proprietary linguistic communications for each database they wanted to link to. Now, ODBC has made the pick of the database system about irrelevant from a coding position, which is as it should be. Application developers have much more of import things to worry about than the sentence structure that is needed to port their plan from one database to another when concern needs all of a sudden alteration.

Through the ODBC Administrator in Control Panel, you can stipulate the peculiar database that is associated with a information beginning that an ODBC application plan is written to utilize. Think of an ODBC information beginning as a door with a name on it. Each door will take you to a peculiar database. For illustration, the informations beginning named Gross saless Figures might be a SQL Server database, whereas the Accounts Collectible informations beginning could mention to an Access database. The physical database referred to by a informations beginning can shack anyplace on the LAN.

The ODBC system files are non installed on your system by Windows 95. Rather, they are installed when you setup a separate database application, such as SQL Server Client or Visual Basic 4.0. When the ODBC icon is installed in Control Panel, it uses a file called ODBCINST.DLL. It is besides possible to administrate your ODBC information beginnings through a stand-alone plan called ODBCADM.EXE. There is a 16-bit and a 32-bit version of this plan, and each maintains a separate list of ODBC informations beginnings.

From a programming position, the beauty of ODBC is that the application can be written to utilize the same set of map calls to interface with any informations beginning, irrespective of the database seller. The beginning codification of the application does n’t alter whether it talks to Oracle or SQL Server. We merely mention these two as an illustration. There are ODBC drivers available for several twelve popular database systems. Even Excel spreadsheets and plain text files can be turned into informations beginnings. The operating system uses the Registry information written by ODBC Administrator to find which low-level ODBC drivers are needed to speak to the informations beginning ( such as the interface to Oracle or SQL Server ) . The burden of the ODBC drivers is crystalline to the ODBC application plan. In a client/server environment, the ODBC API even handles many of the web issues for the application coder.

The advantages of this strategy are so legion that you are likely believing there must be some gimmick. The lone disadvantage of ODBC is that it is n’t every bit efficient as speaking straight to the native database interface. ODBC has had many disparagers make the charge that it is excessively slow. Microsoft has ever claimed that the critical factor in public presentation is the quality of the driver package that is used. In our low sentiment, this is true. The handiness of good ODBC drivers has improved a great trade late. And anyhow, the unfavorable judgment about public presentation is slightly correspondent to those who said that compilers would ne’er fit the velocity of pure assembly linguistic communication. Possibly non, but the compiler ( or ODBC ) gives you the chance to compose cleansing agent plans, which means you finish Oklahomans. Meanwhile, computing machines get faster every twelvemonth.


In an attempt to put an independent database criterion API for Java, Sun Microsystems developed Java Database Connectivity, or JDBC. JDBC offers a generic SQL database entree mechanism that provides a consistent interface to a assortment of RDBMSs. This consistent interface is achieved through the usage of “ plug-in ” database connectivity faculties, or drivers. If a database seller wants to hold JDBC support, he or she must supply the driver for each platform that the database and Java run on.

To derive a wider credence of JDBC, Sun based JDBC ‘s model on ODBC. As you discovered earlier in this chapter, ODBC has widespread support on a assortment of platforms. Establishing JDBC on ODBC will let sellers to convey JDBC drivers to market much faster than developing a wholly new connectivity solution.

JDBC was announced in March of 1996. It was released for a 90 twenty-four hours public reappraisal that ended June 8, 1996. Because of user input, the concluding JDBC v1.0 specification was released shortly after.

The balance of this subdivision will cover adequate information about JDBC for you to cognize what it is approximately and how to utilize it efficaciously. This is by no agencies a complete overview of JDBC. That would make full an full book.

JDBC Goals

Few package bundles are designed without ends in head. JDBC is one that, because of its many ends, drove the development of the API. These ends, in concurrence with early referee feedback, have finalized the JDBC category library into a solid model for constructing database applications in Java.

The ends that were set for JDBC are of import. They will give you some insight as to why certain categories and functionalities behave the manner they do. The eight design ends for JDBC are as follows:


The interior decorators felt that their chief end was to specify a SQL interface for Java. Although non the lowest database interface degree possible, it is at a low plenty degree for higher-level tools and APIs to be created. Conversely, it is at a high adequate degree for application coders to utilize it confidently. Achieving this end allows for future tool sellers to “ bring forth ” JDBC codification and to conceal many of JDBC ‘s complexnesss from the terminal user.

SQL Conformance

SQL sentence structure varies as you move from database seller to database seller. In an attempt to back up a broad assortment of sellers, JDBC will let any query statement to be passed through it to the implicit in database driver. This allows the connectivity faculty to manage non-standard functionality in a mode that is suited for its users.

JDBC must be instrumental on top of common database interfaces

The JDBC SQL API must “ sit ” on top of other common SQL degree APIs. This end allows JDBC to utilize bing ODBC degree drivers by the usage of a package interface. This interface would interpret JDBC calls to ODBC and frailty versa.

Supply a Java interface that is consistent with the remainder of the Java system

Because of Java ‘s credence in the user community therefore far, the interior decorators feel that they should non roll from the current design of the nucleus Java system.

Keep it simple

This end likely appears in all package design end listings. JDBC is no exclusion. Sun felt that the design of JDBC should be really simple, leting for merely one method of finishing a undertaking per mechanism. Leting duplicate functionality merely serves to confound the users of the API.

Use strong, inactive typewriting wherever possible

Strong typewriting allows for more mistake checking to be done at compile clip ; besides, less mistakes appear at runtime.

Keep the common instances simple

Because more frequently than non, the usual SQL calls used by the coder are simple SELECT ‘s, INSERT ‘s, DELETE ‘s and UPDATE ‘s, these questions should be simple to execute with JDBC. However, more complex SQL statements should besides be possible.

Activity Diagram

File Choice


Packet loss appraisal

Packages for loss

Packages with loss

Packet Separation


Use Case Diagram

Choose Text File

Packet Separation


Packet received with loss

Packet loss computation


Sequence Diagram:


Select File

Packet Separation


Loss appraisal

Package receiving system

Selects File

Gives File

Gives Separated package

Sends packages with loss

Calculates Packet loss

Class Diagram


Select File ( )

Send File ( )

Packet Separation

Separation ( )


Queue ( )


Receive Packets ( )

Loss computation ( )

Sample Code:


/* PacketSender */

/* */


import java.awt. * ;

import java.awt.event. * ;

import javax.swing. * ;

import * ;

import * ;


* Summary description for PacketSender



public category PacketSender extends JFrame


// Variables declaration

private JLabel jLabel1 ;

private JLabel jLabel2 ;

private JLabel jLabel3 ;

private JTextField jTextField1 ;

private JTextArea jTextArea1 ;

private JScrollPane jScrollPane1 ;

private JButton jButton1 ;

private JButton jButton2 ;

private JButton jButton3 ;

private JPanel contentPane ;

public float filelength ;

public byte filebyte [ ] =new byte [ 10000 ] ;

public String filstr [ ] ;

public int filint [ ] ;

public char filchar [ ] ;

public int I ;

Socket st ;

// End of variables declaration

public PacketSender ( )


super ( ) ;

initializeComponent ( ) ;


// TODO: Add any builder codification after initializeComponent call


this.setVisible ( true ) ;



* This method is called from within the builder to initialise the signifier.

* Warning: Do NOT modify this codification. The content of this method is ever regenerated

* by the Windows Form Designer. Otherwise, recovering design might non work decently.

* Tip: If you must revise this method, delight backup this GUI file for JFrameBuilder

* to recover your design decently in future, before revising this method.


private nothingness initializeComponent ( )


jLabel1 = new JLabel ( ) ;

jLabel1.setFont ( new Font ( “ Arial ” , Font.BOLD,14 ) ) ;

jLabel2 = new JLabel ( ) ;

jLabel2.setFont ( new Font ( “ Arial ” , Font.BOLD,12 ) ) ;

jLabel3 = new JLabel ( ) ;

jLabel3.setFont ( new Font ( “ Arial ” , Font.BOLD,12 ) ) ;

jTextField1 = new JTextField ( ) ;

jTextField1.setFont ( new Font ( “ Arial ” , Font.BOLD,12 ) ) ;

jTextArea1 = new JTextArea ( ) ;

jTextArea1.setFont ( new Font ( “ Arial ” , Font.BOLD,12 ) ) ;

jScrollPane1 = new JScrollPane ( ) ;

jButton1 = new JButton ( ) ;

jButton2 = new JButton ( ) ;

jButton3 = new JButton ( ) ;

contentPane = ( JPanel ) this.getContentPane ( ) ;


// jLabel1


jLabel1.setText ( “ SENDER ” ) ;


// jLabel2


jLabel2.setText ( “ Open the File ” ) ;


// jLabel3


jLabel3.setText ( “ Status Information ” ) ;


// jTextField1


jTextField1.addActionListener ( new ActionListener ( ) {

public nothingness actionPerformed ( ActionEvent vitamin E )


jTextField1_actionPerformed ( vitamin E ) ;


} ) ;


// jTextArea1



// jScrollPane1


jScrollPane1.setViewportView ( jTextArea1 ) ;


// jButton1


jButton1.setText ( “ Browse ” ) ;

jButton1.addActionListener ( new ActionListener ( ) {

public nothingness actionPerformed ( ActionEvent vitamin E )


jButton1_actionPerformed ( vitamin E ) ;


} ) ;


// jButton2


jButton2.setText ( “ Send ” ) ;

jButton2.addActionListener ( new ActionListener ( ) {

public nothingness actionPerformed ( ActionEvent vitamin E )


jButton2_actionPerformed ( vitamin E ) ;


} ) ;


// jButton3


jButton3.setText ( “ Exit ” ) ;

jButton3.addActionListener ( new ActionListener ( ) {

public nothingness actionPerformed ( ActionEvent vitamin E )


jButton3_actionPerformed ( vitamin E ) ;


} ) ;


// contentPane


contentPane.setLayout ( void ) ;

contentPane.setBackground ( new Color ( 119, 119, 119 ) ) ;

addComponent ( contentPane, jLabel1, 161,4,132,30 ) ;

addComponent ( contentPane, jLabel2, 54,46,192,24 ) ;

addComponent ( contentPane, jLabel3, 119,156,187,24 ) ;

addComponent ( contentPane, jTextField1, 40,70,270,30 ) ;

addComponent ( contentPane, jScrollPane1, 55,184,321,147 ) ;

addComponent ( contentPane, jButton1, 310,70,80,30 ) ;

addComponent ( contentPane, jButton2, 80,110,90,30 ) ;

addComponent ( contentPane, jButton3, 190,110,90,30 ) ;


// PacketSender


this.setTitle ( “ PacketSender ” ) ;

this.setLocation ( new Point ( 135, 133 ) ) ;

this.setSize ( new Dimension ( 437, 400 ) ) ;

this.setDefaultCloseOperation ( WindowConstants.DISPOSE_ON_CLOSE ) ;


/** Add Component Without a Layout Manager ( Absolute Positioning ) */

private nothingness addComponent ( Container container, Component degree Celsius, int ten, int Y, int breadth, int tallness )


c.setBounds ( ten, y, width, tallness ) ;

container.add ( degree Celsius ) ;



// TODO: Add any appropriate codification in the undermentioned Event Handling Methods


private nothingness jTextField1_actionPerformed ( ActionEvent vitamin E )


System.out.println ( “ jTextField1_actionPerformed ( ActionEvent vitamin E ) called. “ ) ;

// TODO: Add any managing codification here


private nothingness jButton1_actionPerformed ( ActionEvent vitamin E )


System.out.println ( “ Loading File ” ) ;

// TODO: Add any managing codification here



FileDialog fd=new FileDialog ( this, ” Open ” , FileDialog.LOAD ) ; ( ) ;

FileInputStream fin=new FileInputStream ( fd.getDirectory ( ) +fd.getFile ( ) ) ;

jTextField1.setText ( fd.getDirectory ( ) +fd.getFile ( ) ) ;

File f = new File ( fd.getDirectory ( ) +fd.getFile ( ) ) ; ( filebyte ) ;

filelength=f.length ( ) ;

jTextArea1.setText ( “ File Loaded ” ) ;

jTextArea1.append ( “ File Length = “ +filelength ) ;

jTextArea1.append ( “ File Size = “ +filelength/1024+ ” KB “ ) ;

filint=new int [ ( int ) filelength ] ;

filchar=new char [ ( int ) filelength ] ;

filstr=new Stringing [ ( int ) filelength ] ;

jTextArea1.append ( “ File Content: ” ) ;

for ( i=0 ; i & lt ; filelength ; i++ )


filint [ I ] = ( int ) filebyte [ I ] ;

filchar [ I ] = ( char ) filint [ I ] ;

filstr [ I ] = ” ” +filchar [ one ] ;

jTextArea1.append ( filstr [ I ] ) ;



gimmick ( Exception er )


System.out.println ( Er ) ;



private nothingness jButton2_actionPerformed ( ActionEvent vitamin E )


System.out.println ( “ Sending Packages ” ) ;

// TODO: Add any managing codification here



st=new Socket ( “ localhost ” ,4500 ) ;

DataOutputStream dos=new DataOutputStream ( st.getOutputStream ( ) ) ;

dos.writeFloat ( filelength ) ;

for ( i=0 ; i & lt ; filelength ; i++ )


dos.writeUTF ( filstr [ I ] ) ;


st.close ( ) ;


gimmick ( Exception ty )




private nothingness jButton3_actionPerformed ( ActionEvent vitamin E )


System.out.println ( “ Exit ” ) ;

// TODO: Add any managing codification here

System.exit ( 1 ) ;


Screen Shootings:



After completing the development of any computing machine based system the following complicated clip devouring procedure is system proving. During the clip of proving merely the development company can cognize that, how far the user demands have been met out, and so on.

Following are the some of the proving methods applied to this effectual undertaking:

Beginning Code Testing:

This examines the logic of the system. If we are acquiring the end product that is required by the user, so we can state that the logic is perfect.

Specification Testing:

We can put with, what plan should make and how it should execute under assorted status. This testing is a comparative survey of development of system public presentation and system demands.

Module Level Testing:

In this the mistake will be found at each person faculty, it encourages the coder to happen and rectify the mistakes without impacting the other faculties.

Unit of measurement Testing:

Unit of measurement proving focal points on verifying the attempt on the smallest unit of software-module. The local information construction is examined to guarantee that the day of the month stored temporarily maintains its unity during all stairss in the algorithm ‘s executing. Boundary conditions are tested to guarantee that the faculty operates decently at boundaries established to restrict or curtail processing.

Integration Testing:

Datas can be tested across an interface. One faculty can hold an inadvertent, inauspicious consequence on the other. Integration testing is a systematic technique for building a plan construction while carry oning trials to uncover mistakes associated with interring.

Validation Testing:

It begins after the integrating testing is successfully assembled. Validation succeeds when the package maps in a mode that can be moderately accepted by the client. In this the bulk of the proof is done during the informations entry operation where there is a maximal possibility of come ining incorrect informations. Other proof will be performed in all procedure where correct inside informations and informations should be entered to acquire the needed consequences.

Recovery Testing:

Recovery Testing is a system that forces the package to neglect in assortment of ways and verifies that the recovery is decently performed. If recovery is automatic, re-initialization, and informations recovery are each evaluated for rightness.

Security Testing:

Security proving efforts to verify that protection mechanism built into system will in fact protect it from improper incursion. The examiner may try to get watchword through external clerical agencies, may assail the system with usage package design to interrupt down any defences to others, and may intentionally do mistakes.

Performance Testing:

Performance Testing is used to prove runtime public presentation of package within the context of an incorporate system. Performance trial are frequently coupled with emphasis testing and necessitate both package instrumentality.

Black box Testing:

Black- box proving focal points on functional demand of package. It enables to derive ets of input conditions that will to the full exert all functional demands for a plan. Black box proving efforts to happen mistake in the undermentioned class:

Incorrect or losing map

Interface mistakes

Mistakes in informations constructions or external database entree and public presentation mistakes.

End product Testing:

After executing the proof testing, the following measure is end product proving of the proposed system since no system would be termed as utile until it does bring forth the needed end product in the specified format. Output format is considered in two ways, the screen format and the pressman format.

User Acceptance Testing:

User Acceptance Testing is the cardinal factor for the success of any system. The system under consideration is tested for user credence by invariably maintaining in touch with prospective system users at the clip of developing and doing alterations whenever required.



The term “ package care ” is used to depict the package technology activities that occur following bringing of a package merchandise to the client. The care stage of the package life rhythm is the clip period in which a package merchandise performs utile work. Maintenance activities involve doing sweetening to package merchandises, accommodating merchandises to new environments and rectifying jobs. Software merchandise sweetening may affect supplying new functional capablenesss, bettering user show and manners of interaction, and upgrading external paperss. Adaptation of package to a new environment may affect traveling the package to a different machine. Problem rectification involves alteration and revalidation of package to rectify mistakes. The sweetening of this undertaking can be accomplished easy. That is, any new functional capablenesss can be added to the undertaking by merely including the new faculty in the home page and giving a hyperlink to that faculty. Adaptation of this undertaking to a new environment is besides performed easy.

Corrective Care:

Even with the best quality confidence activities, it is likely that they client will bring out defects in the package. Corrective care changes the package to rectify defects.

Adaptive Care:

An activity that modifies the package to decently interface with a altering environment. The system has been modified so that assorted alteration include to the new system. In instance of Fund Transfer, adoptive care has been performed, that is in earlier system ( character based UNIX system ) alterations are fixed and if any new alterations are to be included, was a hard undertaking. Now commissariats are given so that the user can specify assorted alterations. Such as, it is designed to suit the new alteration in future.

Enhancement Care:

As package is used, the customer/user will acknowledge extra maps that will supply benefit. Perceptive care extends the package beyond its original functional demands.


Simple techniques that allow users to formalize the measuring end products are introduced. We implemented this method in a new tool, BADABING, which we tested in our research lab. Our trials demonstrate that BADABING, in most instances, accurately estimates loss frequences and continuances over a scope of cross traffic conditions

Future Enhance:

We are besides sing alternate, parametric methods for deducing loss features from our investigation procedure. Another undertaking is to gauge the variableness of the estimations of congestion frequence and continuance themselves straight from the measured informations, under a minimum set of statistical premises on the congestion procedure.


The intent of our survey was to understand how to guarantee end-to-end package loss features accurately with investigations and in a manner that enables us to stipulate the impact on the constriction waiting line. We began by measuring the capablenesss of simple Poisson-modulated probing in a controlled research lab environment dwelling of trade good terminal hosts and IP routers. We consider this trial bed ideal for loss measuring tool rating since it enables repeatability, constitution of land truth, and a scope of traffic conditions under which to subject the tool. Our initial trials indicate that simple Poisson probing is comparatively uneffective at mensurating loss episode frequence or measuring loss episode continuance, particularly when subjected to TCP ( reactive ) cross traffic.

Cite this page

Improving Active Packet Loss Measurement Computer Science Essay. (2020, Jun 02). Retrieved from

Are You on a Short Deadline? Let a Professional Expert Help You
Let’s chat?  We're online 24/7