|
|
 |
|
JProbe® MemoryFeatures- Total View Inside the Virtual Machine – Get insight into every object created by your application. Identify memory leaks caused by unintentional object retention (loitering objects). Also identify excess garbage collection caused by excessive object allocation (object cycling). Plus, you can determine real “Pinned” memory, as well as see detailed Packages, Classes, Methods, Instances, and Garbage Collection views.
- Use-Case Driven Memory Analysis – Isolate and resolve memory leaks and other memory allocation issues faster and easier with minimal overhead, as you read into memory only those objects required for any given user execution scenario or test case; no need to wait for all objects to load into memory, as use-case centric analysis allows you to quickly and easily turn on the Memory analysis tool, run your use-case, stop recording and begin analysis.
- Dynamically Connect to a Running JVM – If you notice a problem while running your application without JProbe, you can leave it running, attach JProbe, and take a snapshot of the heap. When you are done, detach JProbe, and the JVM returns to its pre-connection state. You can easily analyze memory usage without disrupting the application. Note: Sun Java SE 6 JVM running locally is required.
- Reference Graph
 – The Memory Reference Graph visualizes references between objects in the Java heap as a directed graph. Each node in the graph is an instance, with graph edges representing the references from one instance to another making easier visualization and analysis. - Memory Snapshots & Snapshot Differencing – Take a snapshot of the heap, run your tests, and then take another snapshot of the heap when testing is complete. View all of the objects created by your use case that remain in the heap for further analysis. Then, compare memory usage before and after code-enhancing changes with Snapshot Differencing for further quantitative, change impact analysis. You can also generate and share detailed reports on key data and metrics with team members.
- Memory Leak Doctor – Leverage this powerful tool to do the analysis for you. A “what if” capability helps you identify potential sources of memory leaks, and further identify the specific references holding onto those loitering objects that cause these leaks. You can quickly and easily model what would happen if you freed a reference along the reference path; if freeing a reference results in the loitering object being released, then you know exactly what you need to do to fix your code.
- Memory Leak Calculator with “Pinned” Memory Statistics – Calculate memory used by an object and all objects it references. You can also determine the amount of real “Pinned” memory held by a reference to determine the potential size of a memory leak. Pinned memory is the real value that expert developers need to assess and fix memory issues.
- Packages , Classes , Methods & Instance Detail Views – In the Memory Locations View, both Packages and Classes views show you how your program uses memory through different groupings of data – which packages or classes allocated objects, and the size and number of allocations. Next, you will drill down into Methods view, which shows the methods that allocated objects, and includes an Instance pane showing each instance allocated by the method. Then, you can drill down into the Instance Detail view, where you can see at a glance each instance of the suspected loitering object.
- Garbage Monitor – This data included in the Memory snapshot provides analytics for collected objects aggregated over the entire use-case, allowing you to quickly identify and eliminate expensive object cycling.
- Object Cycling Analysis – Perform analysis based on the number of instances garbage collected, size of instances collected, and memory released during a garbage collection.
- HPROF Binary Heap Dumps – Easily import HPROF binary heap dumps and save them as memory snapshots for further diagnosis.
- IBM JVM Advanced Memory Diagnostics – Easily process Text heap dumps and Portable heap dumps without the need to directly instrument your JVM. This feature brings added flexibility and greater confidence to problem resolution support in an IBM JVM environment, providing a stronger, proactive solution useful for the timely diagnosis of production crashes.
Memory Overview Additional Information: Other Useful Sites:
|
|
|
|
|