CompuwareCorporation

Building and deploying reliable

WHITE PAPER

high-performance Java applications

Overview In addition to the complexity of the Java application itself,

consider the added complexity of the deployment environment.
The popularity of J2EE has made multi-tier applications
Organizations normally deploy new Java applications and
commonplace. There is an explosive growth in the use of Web
components in an existing infrastructure of legacy applications,
services, creating new challenges to achieve a high level of
services and databases. Ensuring adequate levels of application
performance for Java applications. Software development
performance and reliability becomes increasingly difficult as
organizations face the task of leveraging new technologies needed to
the complexity of the Java application and its deployment
build these applications on aggressive schedules and integrate them
environment increases.
with existing systems.
Developing, testing and deploying Java applications and components
Application servers provide several configuration options to optimize
in a multi-tier architecture requires careful planning and a deliberate
application performance. Its easy to be reassured by that and to
selection of tools that enable developers to ensure the proper level
postpone thinking about application performance until late in the
of software performance, reliability and overall quality. Since Java
development phase. Experience has shown that this optimistic
development normally occurs on platforms that are a different
approach can be a grave mistake. Many coding and design errors are
architecture than the test and deployment platforms, tool selection
much more difficult to correct late in testing than they are in
criteria must also include functional requirements specific to
development. Application servers simply cant compensate for
each environment.
inefficient coding.

Along with the productivity and technology advancements gained Java performance and reliability
with J2EE come complexity and some unique development
Apart from design-specific logic errors and implementation errors,
challenges, including optimizing code performance, efficient
most software problems can be categorized as performance or
utilization of memory, proper management of threads and effective
reliability issues. Java performance and reliability problems can
testing. This paper will address those challenges and provide a
occur for many reasons, often due to:
solution framework for overcoming them.
Inefficient application codePerformance
Java software development challenges Slow code is a problem in any application. Slow Java code can be
a more difficult problem due to the complexity of the runtime
As a language, object model and runtime environment, Java
environment. Java code can run differently from environment to
technology is extremely powerfulbut not a panacea. Multi-tier
environment. Parts of your Java code may be JIT compiled by one
Java applications can be complex, using a combination of
virtual machine, but interpreted by another. In some cases, your
technologies such as Web services, Java servlets, JavaServer Pages
application may be quite efficient, but may use runtime classes
(JSP), Enterprise JavaBeans (EJB), application servers, web servers,
from the Java SDK that introduce performance bottlenecks to your
servlet engines and standalone Java runtime environments.
application. The Java virtual machine and its method calls into
the underlying operating system can also cause avoidable
performance bottlenecks.
To solve problems with inefficient application code, Java
developers should understand the answers to questions like these:
1. What are the most expensive methods in my code?
2. Which lines of code in these methods are being executed
most frequently, and which lines of code are using the most
CPU time?
3. Can I modify the slowest lines of code for an incremental
improvement in runtime performance?
4. Where are the performance bottlenecks in the Java runtime
classes, virtual machine and operating system?
5. Can I modify my code to avoid using these expensive classes
and methods in favor of a solution that will result in faster
runtime performance?
Poor memory utilizationPerformance + Reliability
Java was intended to be an environment free of memory errors
associated with programmer-managed memory, which are common
in C and C++. While a significant number of problems were
eliminated, other types of memory problems became part of the Java
environment. Dealing with Java memory problems requires a new
approach to analyzing a programs use of memory.
Java developers have a good amount of control over efficient
memory allocation and utilization. Calls to allocate memory in
a Java program are very expensive, and can cause noticeable
performance degradation. Inefficient use of allocated memory
can compound this effect, causing serious reliability problems.
Consider a server-side Java application that services tens of
thousands of users simultaneously. If a Java component misuses
100KB of memory for each user instance, it can easily consume
server resources as load increases, wasting 1GB of memory for every
10,000 users. As server resources are depleted, other applications
will become unstable and could completely cut off application
availability. This is obviously an undesirable situation for any
e-commerce application.
Before a Java application is deployed, its memory utilization should
be carefully examined and optimized. Java developers should
consider questions like these:
1. Which methods in my code are allocating the most memory?
2. Which lines in these methods are responsible for allocating the
most memory?
2
3. How many allocations are made by each function and each line
of code?
4. Can I modify my allocation-intensive code to allocate once and
re-use memory for the lifetime of the method?
5. Are there large blocks of memory being allocated early in
execution that could be delayed or eliminated altogether?
6. Can I avoid using certain Java runtime components that make
inefficient use of memory?
Improper thread managementPerformance + Reliability
By nature, Java is a multi-thread, event-driven environment.
Efficient synchronization and use of threads can dramatically
increase performance and scalability, particularly with server code.
Conversely, poor synchronization techniques and inefficient use of
threads can degrade performance and cause problems with reliability
and scalability. Much like memory utilization problems, thread
problems in a server-side application that services many users
simultaneously can seriously degrade server-side application
performance and reliability.
Improper thread management techniques can result in performance
problems due to thread starvation or thrashingconditions that can
be easily addressed if the cause can be identified. Other thread
problems can seriously affect application reliability, such as deadlock,
unsynchronized access to data and thread resource leaks. These
problems can be time-consuming to resolve without the proper tools.
Thread problems should be suspected and thread behavior analyzed
when a sporadic runtime problem occurs that has no apparent cause,
or when performance problems persist even after code has been
tuned for optimal performance and memory utilization. In such
cases, Java developers should consider questions like these:
1. Does most of the application run acceptably, while certain parts
run sluggishly? [possible thread starvation]
2. Is the entire application inexplicably slow? [possible thrashing
condition]
3. Can I adjust the priority level of my program threads to allow
sluggish threads to get more relative CPU time, or to reduce the
overhead associated with excessive context switching? [possible
cause]
4. Does my program run normally, but occasionally hang for
no apparent reason? [possible timing-related deadlock]
5. Does my program experience corruption of data that is accessed
by multiple threads? [possible unsynchronized access to data]
6. Does my multi-threaded programs runtime behavior conform
to its intended design? [possible cause]
Incomplete testingReliability
Determining how well an application has been tested can be
somewhat subjective, leading to the uncertainty most developers and
development managers experience at milestones such as code check-
in, unit testing, or integration testing and final release. At each
milestone, Java developers should ask:
1. How much of the application code was actually tested or, even
more important, how much code was NOT tested?
2. Are the current test suites adequate for exercising all of
the application code? Did the entire test suite execute prior
to deployment?
3. How stable is the code base?
4. What percentage of the code base was modified just prior
to release?
5. Were test suites revised to exercise the most recent
code changes?
Solving Java performance and reliability problems
What can a software development organization do to minimize
or eliminate performance and reliability problems from a Java
application? DevPartner Java Edition, from Compuware, can help
developers resolve these problems quickly and easily, producing
robust Java applications.
DevPartner Java Edition is a suite of software development
productivity tools that help developers build reliable, high-
performance applications and components with Java technology by
solving problems with runtime performance, memory utilization, and
multi-threading. The remainder of this section describes the various
tools and technologies in DevPartner Java Edition, and how each
can help solve or prevent performance and reliability problems in
your Java applications and components.
Performance profiling
DevPartner Java Edition includes a performance profiler that
automatically locates Java performance bottlenecks and reports
application and component performance data in an accurate,
intuitive interface. The performance profiler provides complete top-
to-bottom profiling capability including Java-interpreted code, JIT-
3
compiled code, third-party components, JavaServer Pages, Enterprise
Java Beans and Web services, as well as the virtual machine and
underlying system code. When comparing the DevPartner
performance profiler to other Java profiling tools, an important
point to consider is the value of complete top-to-bottom visibility.
The DevPartner performance profiler accurately measures time spent
in virtual machine methods and in OS methods separately from
time spent in Java application code. This makes it a fast and easy-to-
use tool that can accurately identify the most expensive performance
bottlenecks.
Memory profiling
DevPartner Java Edition includes a memory profiler that
automatically locates memory-intensive methods in Java code. With
an accurate profile of a Java programs memory usage, developers can
improve the runtime performance and resource utilization of their
code by optimizing methods that consume or waste the most
memory. The memory profiler saves valuable development time
by helping developers quickly locate inefficient code that would
otherwise take hours or days to find manually.
The DevPartner memory profiler is fast, easy to use and does NOT
require any code re-compiling. In traditional Sun Java environments
it uses a very fast, lightweight instrumentation technique combined
with the standard Java Virtual Machine Profiler Interface to collect
memory-usage statistics with the minimum amount of intrusion.
Thread analysis
DevPartner Java Edition includes a thread analyzer that helps
developers find multi-threading problems that can degrade Java
performance and reliability. The thread analyzer dramatically
reduces the time it takes developers to find and fix runtime
problems in multi-threaded Java applications and components.
Test coverage analysis
DevPartner Java Edition includes a code coverage analyzer,
TrueCoverage, that allows developers and testers to automatically
locate untested code and script in Java applications, components
and Web pages. This helps development teams save testing time and
improve code reliability by measuring and tracking test execution
during development.
Code coverage is commonly perceived to be a QA testing tool.
However, the DevPartner code coverage analyzer delivers value
as a developer tool as well. It can be used to measure and track
tested and untested code prior to check-in, unit testing or
integration testing.
CompuwareCorporation

When comparing code coverage analyzers, consider the importance Summary

of measuring test coverage of all your Java codeincluding script
code such as JavaScript and JavaServer Pagesas well as code base
stability. In addition to helping developers ensure adequate test
coverage in these areas, DevPartner Java Edition also measures
code volatilityhow much a code base changes over time. With
a project-wide view of test coverage and code base volatility,
developers and development managers can deliver Java applications
with a higher level of confidence.
Underlying technology
Compuware DevPartner Java Edition uses a byte code
instrumentation technique that is completely transparent to the user.
DevPartner tools work with most standard Java virtual machines
and instrument Java classes on the fly as they are being loaded
into the virtual machine. This technique has proven to be highly
reliable, requiring no modification with new VM revisions. It
also allows the developer to use a wide range of standard virtual
machines to test and tune their Java code, ensuring more successful
deployment, higher performance and better reliability.
As weve seen, todays multi-tier Java applications combine many
different technologies and are prone to problems with runtime
performance, memory utilization, multi-threading and test coverage.
While the benefits of Java development are clear, the challenges
in dealing with these development problems can be intimidating.
DevPartner Java Edition from Compuware proves highly capable
of delivering powerful features that can address these development
problems while substantially raising Java code performance and
reliability, as well as developer productivity. DevPartner Java
Edition is implemented with proven underlying technology that
allows developers a high degree of flexibility and compatibility in a
wide range of development and deployment environments.
Compuware is committed to the Java platform and complementary
technologies, and will continue to support enterprise Java developers
with new, innovative tools and features in the DevPartner family
of products.

Compuware products and professional servicesdelivering IT value

Compuware Corporation development, improve the control and employee than 90 percent of the
(NASDAQ: CPWR) maximizes quality and enhance the productivity throughout the Fortune 100 companies. Learn
the value IT brings to the performance of critical IT organization. Founded in more about Compuware at
business by helping CIOs business systems while 1973, Compuware serves www.compuware.com.
more effectively manage the enabling CIOs to align and the worlds leading IT
business of IT. Compuware govern the entire IT portfolio, organizations, including more
solutions accelerate the increasing efficiency, cost

Compuware Corporation Corporate Headquarters

One Campus Martius
Detroit, MI 48226
For automated-testing, please visit our web site at www.compuware.com

All Compuware products and services listed within are trademarks or registered trademarks
of Compuware Corporation. Java and all Java-based marks are trademarks or registered
trademarks of Sun Microsystems, Inc. in the United States and other countries.
All other company or product names are trademarks of their respective owners. 10/04
2004 Compuware Corporation