MAT ist ein umfangreiches Speicheranalyse-Werkzeug, welches es ermöglicht Heap-Dump-Informationen mit dem Dateiformat ".hprof" einzulesen und in vielfacher Art darzustellen, um dem Entwickler die Möglichkeit zu bieten, Speicherlecks schnell und zielsicher ausfindig zu machen.
Durch Speicherüberlauf hervorgerufene Programmabstürze, deren Ursache mit einfachen Bordmitteln normalerweise schwierig nachzuvollziehen sind,
können mithilfe des Eclipse Memory Analyzers im Nachhinein detailliert betrachtet und nachvollzogen werden.
Der infolge eines Speicherüberlauf generierte Heapdump des Java-Programms wird ganz einfach eingelesen und anhand von vielen auswählbaren
Ansichten übersichtlich dargestellt, so dass ein Einblick in das komplette Programm zum Zeitpunkt des Absturzes möglich ist. Mit ein wenig
Know-How kann dann schnell die speicherbelastende Softwarekomponente ausfindig gemacht werden.
Analyse von durch Java generierten Heap-Daten nach Speicherüberlauf innerhalb eines Java-Programms.
MAT ist sowohl als Standalone-Programm, als auch als Eclipse-PlugIn einsetzbar, da es ohnehin die grafischen Komponenten von Eclipse benutzt.
MAT kann auf http://www.eclipse.org/mat/downloads.php in der aktuellsten Version heruntergeladen werden.
Die Standalone-Version ist für folgende Plattformen jeweils als zip-Archiv verfügbar:
Zur Installation muss das zip-Archiv in einen beliebigen Ordner entpackt werden. Die startbare Datei befindet sich daraufhin im Ordner "mat" unter dem Dateinamen "MemoryAnalyzer" (unter Linux, Solaris und MacOSX) bzw. "MemoryAnalyzer.exe" (unter Windows).
MAT kann per Software-Update in eine vorhandene Eclipse-Umgebung als Plugin eingebunden werden. Hierzu ist über "Help"
-> "Software Updates..." der Button "Add Site..." zu wählen. Unter "Location" muss die URL
"http://download.eclipse.org/technology/mat/0.7/update-site/" eingegeben und mit "OK" bestätigt werden.
Daraufhin kann im linken Fensterteil der Memory Analyzer über die eingerichtete "Memory Update Site" mit Setzen eines Häkchens
ausgewählt und mit "Install" installiert werden.
Anschließend muss Eclipse neu gestartet werden. Die "Memory Analysis"-Ansicht
lässt sich daraufhin über "Open Perspective" -> "Other" öffnen.
Desweiteren verlangt MAT (in der Eclipse-PlugIn-Variante) auch die Installation der "BIRT Chart Engine", welche der Dartellung der Ergebnisse in Chart-Diagrammen dient.
Allerdings wird die aktuelle Version 2.3.1 anscheinend nicht erkannt und nach dem Parsen einer ".hprof"-Datei innerhalb der Eclipse-Umgebung lediglich
die Fehlermeldung "BIRT Chart Engine (>2.2.2) not available" ausgegeben.
In der Standalone-Version sind die BIRT-Funktionen schon enthalten und funktionieren hier anstandslos.
Der Eclipse Memory Analyzer besitzt ein eingebautes und hilfreiches Tutorial mit Anweisungen zum sinngemäßen Umgang mit dem zur Verfügung gestellten Funktionsumfang des Tools.
Diese Seite gibt an, dass keine offizielle Dokumentation in Dokumentenform für das MAT-Projekt existiert.
Lediglich ein kleines Wiki mit einer knappen Anleitung zur Erstellung von "HPROF"-Dateien, sowie eine Kurze Beschreibung sind
auf der Wiki-Seite von SAP zu finden.
Die Projektseite scheint seit der Projekt-Erstellung nicht sonderlich geändert worden sein. Der Internetauftritt ist sowohl auf der durch Eclipse, als auch der durch SAP gehosteten
Web-Seite sehr informationsarm.
Allerdings muss hier beachtet werden, dass sich das Projekt erst in der Inkubationsphase befindet und zu erwarten ist, dass zukünftig weitere Informationen
zur Verfügung gestellt werden.
Es existiert eine Newsgroup in welcher Nutzer-Fragen regelmäßig beantwortet werden, sowie eine Mailing-List, über welche aktuelle Neuerungen veröffentlicht werden.
Die Installation und das Laden von Heap-Dump-Informationen in das Programm gestalten sich sehr einfach, jedoch ist es umso schwieriger, die dargestellten Informationen auf Anhieb zu verstehen und sinngemäß auszuwerten. Hier kann jedoch das eingebaute Tutorial als Hilfestellung jederzeit zu Rate gezogen werden.
MAT funktioniert vollautomatisch. Nach dem Parsen der Heap-Informationen werden automatisch Ansichten generiert. Jedoch muss hier differenziert werden, dass es sich um kein "aktives" Tool handelt, welches während der Laufzeit eines Programms Daten mitschneidet, es lassen sich lediglich Heap-Dump-Dateien einlesen, welche daraufhin vollautomatisch analysiert und grafisch bzw. in Tabellenform dargestellt werden.
-XX:+HeapDumpOnOutOfMemoryError.
-XX:+HeapDumpOnOutOfMemoryError gestartet werden.
Ein einfaches Tool zum Zeichnen von Polygonen per Java2D wird mit einer Funktion erweitert, welche automatisch eine Vielzahl von Polygonpunkten auf der Zeichenfläche generiert.
Polygonpunkte sind Paare von Integer-Werten und belegen somit nur sehr wenig Speicher.
Zunächst wird im Projektordner ein Verzeichnis "HeapDump" angelegt, in welches die Dump-Dateien später abgelegt werden sollen.
Um zu ermöglichen, dass bei Auftreten eines Speicherüberlaufs überhaupt eine Dump-Datei erzeugt wird, muss im "Run"-Profil der Klasse, welche die main()-Methode
beinhaltet, unter "Arguments" der VM-Parameter "-XX:+HeapDumpOnOutOfMemoryError" übergeben werden.
Unter "Working Directory" wird der Punkt "Other" gewählt und "${workspace_loc:Polygon/HeapDump}" als Pfad eingetragen. Dieser verweist in den zuvor erstellten Ordner
"HeapDump" im Projekt.
Da das Polygon-Zeichenprogramm von Natur aus nicht sehr speicherhungrig ist, kann hier die Erzeugung eines Heap-Dumps zusätzlich durch das Setzen einer geeigneten Speicherplatzbegrenzung manipuliert
werden. Der ergänzende Parameter "-Xms4m -Xmx8m" teilt der Java-VM mit, bei Programmstart 4 MB und daraufhin maximal 8 MB im Arbeitsspeicher zu belegen. Somit wird in jedem Fall bei
Überschreiten der 8 MB-Grenze der Heap-Dump wie gewünscht geschrieben.
Die Konfiguration sollte wie folgt aussehen:
Das Programm kann nun mit "Run" gestartet werden:
Daraufhin wird der vorbereitete "Hardcore-Test" mit Drücken des untersten Buttons gestartet. Das Programm generiert tausende Polygonpunkte und öffnet anschließend ein Panel zur Anzeige des Zeichenfeldes. Hier ist sofort "optisch sichtbar", dass das Programm aufgrund eines Speicherüberlaufs bei der Generierung der Punkte unterbrochen wurde:
Außerdem gibt die Konsole folgende Meldung aus, welche in den ersten drei Zeilen darauf hinweist, dass der erwartete Dump erzeugt und gespeichert wurde:
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid16849.hprof ...
Heap dump file created [12128906 bytes in 0.225 secs]
Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:2746)
at java.util.ArrayList.ensureCapacity(ArrayList.java:187)
at java.util.ArrayList.add(ArrayList.java:378)
at de.fhwiesbaden.poly.Polygon.addPoint(Polygon.java:13)
at de.fhwiesbaden.poly.PolygonGUI.highEndTest(PolygonGUI.java:337)
at de.fhwiesbaden.poly.PolygonGUI$12.actionPerformed(PolygonGUI.java:260)
...
2. Parsen des Heap-Dumps mit dem Memory Analyzer
Der "MemoryAnalyzer" wird nun als Standalone-Tool gestartet. Es erscheint ein schon von Eclipse bekanntes Begrüßungsfenster mit dem Zugriff auf die Hauptfunktionen:
Der geladene Heap-Dump ist daraufhin über die Menü-Symbole unterhalb des "xxx.hprof"-Reiters anhand verschiedener Ansichten darstellbar:
Dieses Symbol öffnet die im Folgenden zu sehende Überblick-Seite. In einem Chart-Diagramm werden hier die Klassen dargestellt, deren Objekte bei Ausführung des
Programms die höchste Speicherbelastung hatten. Jede Klasse wird durch ein Kuchenstück dargestellt, anhand dessen Größe auf den relativen Anteil des Gesamtspeichers
geschlossen werden kann. Außerdem sind zu jedem Kuchenstück die absoluten Größen in Byte/KByte/MByte bzw. die Gesamtgröße (in diesem
Beispiel "Total: 7 MB") aufgeführt:
Beim Überfahren der Diagrammteile mit der Maus werden im linken Fensterbereich nähere statistische Informationen und Objektwerte zum jeweiligen Klassentypen ausgegeben.
Zusätzlich befinden sich im unteren Bereich Verknüpfungen zu den weiteren Dump-Ansichten.
Das folgende Klassen-Histogramm zeigt die im Heap-Dump aktiven gekennzeichneten Klassen an mit
Man kann hier z.B. sehen, dass Objekte der Klasse "de.fhwiesbaden.poly.Pair", welche jeweils eine Koordinate eines
Polygonpunktes speichern, beim Heap-Dump genau 302765 mal im Speicher vorhanden waren und 4844240 Byte im Speicher belegt haben.
Im linken Fensterbereich "Inspector" werden zusätzliche Details zu den ausgewählten Objekttypen angezeigt. Hier werden u.a. Paketname (de.fhwiesbaden.poly),
Klassenname (Pair), Klassen-ID (0xac28f9c0), die Größe eines einzelnen Objekts (8 Byte) und GarbageCollector-Informationen (no GC root) ausgegeben:
Der "Dominator Tree" zeigt für ein bestimmtes Objekt welche anderen Objekte von diesem
abhängen und vom Garbage-Collector entfernt werden, sobald dieses Objekt entfernt wird.
Auch hier werden im linken Fensterbereich detaillierte Attributinformationen zum ausgewählten
Objekt ausgegeben.
Ein Objekt der Klasse "Polygon" speichert in diesem Beispiel viele Objekte der Klasse "Pair",
welche die Polygonpunkte eines Polygons darstellen. Die Polygone selbst sind wiederum in einer ArrayList gespeichert.
Somit ergibt sich eine Hierarchie von Objektcontainern, Objekten und abgeleiteten Objekten, die im MAT als "Dominator Tree" bezeichnet wird:
OQL ist eine eingebaute "Object Query Language", mit welcher sich im SQL-Stil Abfragen auf die Heap-Informationen schicken lassen.
Beispiel:
SELECT *
FROM de.fhwiesbaden.poly.Polygon
Über das Export-Symbol kann das Ergebnis auch im Format ".html", ".txt" bzw. ".csv" exportiert werden.
Folgendes Ergebnis erzielt z.B. der Export ins Textformat:
Class Name | Shallow Heap | Retained Heap | Retained Heap
--------------------------------------------------------------------------------------
| | |
de.fhwiesbaden.poly.Polygon @ 0xb3b891a0| 24 | 5.957.400 | 5.957.400
de.fhwiesbaden.poly.Polygon @ 0xb3b76e30| 24 | 1.040 | 1.040
de.fhwiesbaden.poly.Polygon @ 0xb3b76a20| 24 | 1.040 | 1.040
de.fhwiesbaden.poly.Polygon @ 0xb3b5ef78| 24 | 97.496 | 97.496
Total: 4 entries | | |
--------------------------------------------------------------------------------------
Mit dem "Expert System Test" lassen sich Reports im html-Format erstellen:
Die Reports werden als zip-Dateien im HeapDump-Ordner abgelegt und können später mit jedem beliebigen Web-Browser angezeigt werden.
Der Query-Browser bietet einigen Shortcuts und Suchmöglichkeiten zur Anzeige spezieller Informationen und bietet
dazu Such- und Eingabemasken und Optionen zur Auflistung und Gruppierung von Daten.
Da diese Funktionen aber weder im eingebauten Tutorial, noch irgendwo sonst dokumentiert sind, soll an dieser Stelle nicht weiter darauf eingegangen werden.
Hier kann nach Objekten in Form von hexadezimalen Objektadressen gesucht werden.
Keine gefunden.