 |
Try It
Request a risk-free, 14-day evaluation.
|
|
|
Java Development Preview
Whether your Java applications run on a single machine or across multiple computers, DevPartner Java™ Edition arms project teams with the capabilities to handle the runtime performance, memory and threading issues typical of the multi-tiered architecture of Java development. Without requiring extensive training, the DevPartner web browser interface gets cross-functional teams working with detailed analysis and profiling techniques to fix underlying issues fast. Project teams can work together at any development stage using their standard browsers, without installing software or licenses locally, reworking their code or changing their standard practices. The result is more reliable Java code delivered on schedule.
Contents
Analyzing performance
How well an application performs while under development and test and ultimately when deployed into the run-time environment is a real problem for Java programmers. Performance issues are usually more complex than originally thought and often demand a laborious step-through of the process and an exhaustive analysis of the underlying program code.
With DevPartner Java™ Edition, you can stop guessing about application performance tuning and start pinpointing application problems. DevPartner performs comprehensive analysis, computes relevant statistics and displays its conclusions and tuning suggestions in an easy-to-understand format.
DevPartner pinpoints and prioritizes source code problems, including:
- computational performance
- perceived performance
- start-up time
- scalability
- memory consumption.
|
DevPartner supplements this analysis with detailed findings on exactly where performance bottlenecks and code hot spots reside. DevPartner works across all application tiers and multiple systems concurrently, and delivers this information right to your workstation. |
|
|
|
|
|
DevPartner provides various ways to look at performance analysis results. Whatever direction you take, you can drill down into your data using one of the graphs provided after DevPartner generates a profiling session. Choose a graph that focuses on the performance problem that you are trying to solve. |
|
|
|
|
This first graph displays entry points with the slowest average response time. You can find where the application may be slowing down, such as at start-up or in response to user input. During data analysis, DevPartner prioritizes the data by entry point, so you can see immediately where to focus your tuning efforts. |
|
|
|
|
|
DevPartner also shows you exactly which methods consume the most CPU time, which could slow down performance. Prioritizing your efforts is clear with the visual aids DevPartner provides. |
|
|
|
|
|
If you need additional details, pop-ups with added information are provided, which are available at any point in your diagnostic efforts with DevPartner. |
|
|
|
|
|
The Methods Spending the Most Time Waiting graph shows the causes for excessive wait times that may be affecting performance, such as methods that are executing slowly, or not at all. |
|
|
|
|
|
DevPartner provides detailed performance data in a meaningful and prioritized fashion. |
|
|
|
|
|
The call graph helps you determine exactly where the problematic performance components are located in an application's call structure. Use this graph to better understand the methods that might be affected if a change is made.As you can see, DevPartner helps identify inefficient areas in your Java program code where performance problems might hinder application responsiveness and efficiency so that you can create a high-performing application. |
|
|
|
|
|
|
|
Analyzing memory
DevPartner Java™ Edition analyzes how your Java programs allocate memory. If your Java application's object use is not efficient, the result can be poor performance, or even exhausted memory resources. DevPartner presents a live view of your application's memory use as it runs. |
|
|
|
|
|
DevPartner memory analysis identifies methods or lines of code that consume memory and allows you to quickly drill down to the method or line of code causing the problem. This provides you with an in-depth understanding of how your program uses memory and the critical information you need to optimize memory use. DevPartner also monitors the real-time heap for every object.
When the program terminates, DevPartner displays the results in the session window to help you identify and address ineffective object use with memory leaks, temporary object usage and RAM footprint, the three most critical areas for memory management in Java. |
|
|
|
|
When you analyze a Java application for object references, DevPartner gives you a live view of the application as it executes. This real-time graph shows how your application uses objects, prioritizing areas for improving the application's effectiveness, scalability and performance. DevPartner displays views showing specific information such as: |
|
|
|
|
- classes with the most average leaked instance bytes including children
- objects that refer to the most leaked bytes
- methods with the most leaked bytes
- classes with the most bytes.
Different memory problems create characteristic patterns, so the real-time graph provides the first clue to the existence and nature of a memory problem. In this example, the series of high and low spikes mean the application is most likely using temporary or short-lived objects that are consuming memory
|
|
|
|
|
When you elect to view temporary objects, DevPartner presents a summary with two separate charts-the entry points that require the most temporary space and methods that require the most temporary space. From here, you can drill down to see summary info, and view the call graph or source code, to the point where you can identify which lines of code are generating objects, and how much memory these objects are consuming-all in a single view. |
|
|
|
|
|
The amount of memory consumed by your application can have a major impact on how well the application performs. The larger the amount of memory consumed (RAM footprint), the more likely it is that the application will run slowly and scale poorly. Memory leaks-the allocation of memory that is not freed by the time at the point at which you view memory data-can bloat your application's RAM footprint. |
|
|
DevPartner provides a view of the RAM footprint that focuses on classes and methods and identifies what is taking up current memory. This allows you to prioritize your investigation and verify what is currently held in memory.
DevPartner memory analysis saves valuable development time by helping developers quickly locate inefficient code that would otherwise take hours or days to find manually. |
|
|
|
|
|
|
Analyzing code coverage
Code coverage is central to development and testing. Developers use coverage tools to ensure that unit tests adequately exercise their code before checking it in, and testers use coverage tools to ensure that test suites adequately exercise their code before release. |
|
|
|
|
|
DevPartner Java™ Edition includes a code coverage analysis tool that locates untested or tested code in software applications and components developed in Java. DevPartner provides you detailed insight on the execution of code that has been recently changed or is currently undergoing changes. This unique capability identifies the most recently changed or "volatile" code, which helps you understand the true quality of your testing efforts.
By measuring and tracking code execution and code base volatility throughout development, DevPartner saves testing time and reduces redundant tests by focusing on fixing the problems and re-testing only the modified portions on their code, thus improving code reliability.
DevPartner also describes the level of testing that the code has already undergone. It helps prioritize testing and focus on those areas that need further attention—across all tiers and systems. The result is a complete picture of testing efforts in your entire environment. |
|
|
|
|
DevPartner gathers detailed coverage data for Java applications and reports the data on the Coverage Results Summary tab. You can use the DevPartner graphs on methods, classes and merged sessions to make informed decisions on how to improve tests, increase code coverage and reduce redundant testing. |
|
|
|
|
|
The Methods with the Most Lines Not Covered graph displays the areas of the application that have the most untested code.
The Classes with the Most Lines Not Covered graph shows you which classes have the most untested methods.
Sometimes this is the only page that you need to see, but you can drill down to view more information if you are interested. |
|
|
|
|
The DevPartner session control page for coverage analysis focuses on specific areas of an application, provides snapshots of collected data, and gives you the ability to clear the data and continue recording. |
|
|
|
|
|
DevPartner lets you gather data over time-across all tiers and systems—by running the application or component more than once and collecting the data into multiple session files that you can later merge into a single summary file.
Gathering this data lets you track changes in your code to gauge the volatility of the code base. If several members of your development team use DevPartner, you can merge their coverage session files to easily create project-wide coverage statistics. |
|
|
|
|
|
Finding conditions that can lead to deadlocks in Java applications is critical—but because deadlocks are often sporadic, they're difficult to find. |
|
|
|
|
|
DevPartner thread error detection is integrated into coverage analysis to find which Java threads are synchronizing locks out of order. DevPartner provides insight not only into discovered deadlocks, but potential deadlocks as well. DevPartner detects conditions by watching the application execution paths and comparing them against all possible call path combinations to determine if a deadlock might occur.
DevPartner code analysis helps development teams save testing time and improve code by measuring and tracking code execution and code base stability during development. |
|
|
|
|
Request a trial version or purchase DevPartner Java™ Edition now. |
|
|
|
