Java-Profiling

Werbung
Seminararbeit
in der Vorlesung
Softwareengineering
Dozent: Herr Prof. Dr.-Ing. Olaf Herden
zum Thema
Java-Profiling
Kolja Braden, Philipp Daubenschüz
Studiengang Informationstechnik
Berufsakademie Horb
Florianstr. 15
72160 Horb a. N.
[email protected]
[email protected]
31. Oktober 2005
Seminararbeit – Java Profiling
1 EINFÜHRUNG......................................................................................................... 3
1.1
Begriffsdefinitionen............................................................................................................................. 3
1.1.1 Profiling ............................................................................................................................................... 3
1.1.2 Performance....................................................................................................................................... 3
1.2 Was geschieht beim Profiling? ................................................................................................................ 3
1.3 Wann Profilen?............................................................................................................................................. 4
1.4 Vorgehensweise .......................................................................................................................................... 4
2
VERSCHIEDENE PROFILINGANSÄTZE........................................................... 6
2.1 Profiling mit dem JVMPI (Java Virtual Machine Profiling Interface) .............................................. 6
2.2 Profiling durch Instrumentierung............................................................................................................ 8
2.3 Profiling durch manuelle Zeitmessung.................................................................................................. 8
3
PROFILING- WERKZEUGE ..............................................................................10
3.1
Hyades .................................................................................................................................................. 10
3.1.1 Installation............................................................................................................................................. 12
3.1.2 Strategie und Bewertung .................................................................................................................... 12
3.1.3 Profiling mit Hyades ............................................................................................................................ 13
3.1.4 Fazit ....................................................................................................................................................... 15
3.2 JRat ............................................................................................................................................................... 16
3.2.1 Installation............................................................................................................................................. 16
3.2.2 Strategie................................................................................................................................................ 16
3.2.3 Profiling mit JRat.................................................................................................................................. 16
3.2.4 Fazit ....................................................................................................................................................... 19
3.3 HP- JMeter /Xrunhprof aus dem JDK ................................................................................................... 20
3.3.1 Überblick über die Funktionalitäten................................................................................................... 23
3.3.2 Fazit ....................................................................................................................................................... 27
4
BEWERTUNG VON PERFORMANCEANALYSEN ..........................................28
Kolja Braden, Philipp Daubenschüz
2
Seminararbeit – Java Profiling
1 Einführung
In der Softwareentwicklung gibt es während der Programmerstellung verschiedene Teilziele,
die auf Anhieb nur sehr selten zu erreichen sind. Dazu zählen die Lesbarkeit des Codes, die
Funktionalität des zu entwickelnden Programms sowie seine Leistungsfähigkeit und
Ausführungszeit. Insbesondere die Abschätzung der Laufzeit und des Speicherbedarfs sind
während der Erstellung nur sehr bedingt möglich. Hilfreich können hierbei ProfilingWerkzeuge sein, von denen in dieser Arbeit einige vorgestellt werden sollen. Für das
grundsätzliche Verständnis ist es aber zuallererst notwendig, Begriffe zu klären und
darzustellen, in welchen Situationen Profiling sinnvoll ist und welche Ansätze dazu
existieren.
1.1 Begriffsdefinitionen
1.1.1 Profiling
Profiling – profilieren – einer Sache, jmdm. eine besondere charakteristische, markante
Prägungen geben; sich im Profil abzeichnen
[Dude04]
Unter „Profiling“ versteht man die Analyse der Laufzeit Performance indem
während der Ausführung der Anwendung Messdaten ermittelt werden.
[AdAd03]
1.1.2 Performance
Performance bezeichnet in der Informatik die Effizienz von Programmen und Hardware
bezüglich des Ressourcenverbrauchs und der Qualität der Ausgabe.
1.2 Was geschieht beim Profiling?
Mit einem Profilingtool kann man, eine funktionierende Software über den zeitlichen Ablauf
analysieren. Es können Laufzeitaussagen getroffen werden und genaue Analysen gemacht
werden. Es kann lokalisiert werden, welche Programmteile die Ressourcen des Rechners
Kolja Braden, Philipp Daubenschüz
3
Seminararbeit – Java Profiling
wie viel Zeit, in Anspruch nehmen. Softwareentwickler haben damit die Möglichkeit so
genannte Flaschenhälse im Programm zu ermitteln und in weiteren Entwicklungsschritten
unter dem Performance-Aspekt zu überarbeiten. Je nach Werkzeug stehen grafische
Aufbereitungsmöglichkeiten der Analyse zur Verfügung, mit denen die Analysen über das
Programm übersichtlich aufbereitet werden können.
1.3 Wann Profilen?
In der Software- Entwicklung arbeiten im Allgemeinen viele Personen an einem Projekt.
Anfangs steht in Entwicklungsprojekten die Lesbarkeit des Codes im Vordergrund. Auf
Performance- Kriterien wird wenig Wert gelegt. Dies macht Sinn, da die neu entwickelte
Software am Anfang des Projektes erstmal grundsätzlich funktionieren soll. Wenn ein
Programm eines Projektes die funktionale Spezifikation erfüllt, sind Profilings und
Performanceanalysen sinnvoll. Mit den Ergebnissen der Analysen können Engpässe in der
Software lokalisiert werden. In einem Refactoring kann die Software zu einem späteren
Zeitpunkt im Projekt in den Performance- Belangen optimiert werden.
Es steht bei diesem Refactoring ein Referenzstand zur Verfügung, mit dem die Funktionalität
des überarbeiteten Codes überprüft werden kann. Mit einem Profiling kann man die
erreichten Performanceverbesserungen bestätigen und kann damit genau dokumentieren
und analysieren, wie sich einzelne Veränderungen im Code auswirken.
1.4 Vorgehensweise
In einem ersten Schritt wird das zu optimierende Programm in einer Profilingumgebung
gestartet. Es werden von der entsprechenden Profilingumgebung während der Ausführung
Daten gesammelt. Im nächsten Schritt werden die Profiling- Daten analysiert. Wenn die
performancekritischen Stellen lokalisiert sind, können alternative Algorithmen entwickelt
werden.
Kolja Braden, Philipp Daubenschüz
4
Seminararbeit – Java Profiling
Diese Algorithmen müssen die gleiche Funktionalität haben, und schneller in ihrer
Ausführung sein. Die Optimierungsschritte sollten nicht zu umfassend sein. Wenn ein
Ersatzalgorithmus gefunden ist, sollte dieser eingebunden werden. Es sollte sichergestellt
werden, dass der Algorithmus alle Aufgaben korrekt erfüllt. Mit einem Profiling des neu
eingebundenen Algorithmus kann die genaue Performancesteigerung ermittelt werden.
Ineffiziente Fehlentwicklungen können frühzeitig ausgeschlossen werden. Wenn zu große
Pakete bearbeitet werden, könnten wenige ineffiziente Code- Fragmente viele Performance
steigernde Maßnahmen zunichte machen. So könnten die besseren Ansätze des zu großen
Entwicklungsschrittes leichtfertig verworfen werden.
Kolja Braden, Philipp Daubenschüz
5
Seminararbeit – Java Profiling
2 Verschiedene Profilingansätze
2.1 Profiling mit dem JVMPI (Java Virtual Machine Profiling
Interface)
Das JVMPI wurde mit dem JAVA 2 SDK eingeführt und ist eine Schnittstelle, die es einem
Profiler Agent ermöglicht, die Java Virtual Machine (VM) zu steuern und umgekehrt der VM
ermöglicht, Ereignisse an den Profiler Agent zu senden. Die VM und der Profiler Agent
laufen im selben Prozess. Durch eine Profiler- Benutzer- Schnittstelle, die in einem
separaten Prozess läuft, können die Messdaten dem Benutzer zur Verfügung gestellt
werden.
Abbildung 2.1: Konzept des JVMPI
Der Profiler Agent ist berechtigt, die VM zur Laufzeit steuern, d. h. er kann z. B. die VM zur
Laufzeit benachrichtigen, über welche Ereignisse er informiert werden will. Dadurch ist der
Benutzer in der Lage, nur die für ihn relevanten Daten aufzuzeichnen und unnötigen
Overhead zu vermeiden. Damit ist es möglich unerwünscht große Abweichungen der
Profilingdaten von der realen Performanz zu minimieren. Des Weiteren bietet das JVMPI an,
die Garbage Collection zu steuern, d.h. sie entweder manuell zu starten oder aber ihre
Ausführung zu verhindern. Es kann zu jedem Zeitpunkt der Zustand und Aufrufbaum
einzelner Threads ermittelt werden. Auch die Dauer bzw. das Ende des Profilingvorgangs
kann über das JVMPI vorgegeben werden.
Umgekehrt ist auch die VM in der Lage, den Profiler Agent über eine seiner Methoden, über
verschiedene Ereignisse zu benachrichtigen, zum Beispiel:
•
Initialisierung der VM
•
Methodenaufrufe oder das Verlassen von Methoden
•
Erstellung oder Freigabe von Objekten
Kolja Braden, Philipp Daubenschüz
6
Seminararbeit – Java Profiling
•
Start und Ende von Threads
•
Laden von Klassen
•
Start oder Ende von Garbage Collecting
Das Profiler-Front-End erhält vom Profiler-Agent die gewünschten Informationen und
verarbeitet sie so, dass die Benutzer damit weiterarbeiten können (graphische Ausgabe,
Speichern in Datei, usw.). Mit Hilfe dieser Informationen ist es nun möglich, verschiedene
Ausgaben zu generieren:
•
Heap Profiling (Speicherbedarfsanalyse)
•
CPU-Zeit Profiling (Laufzeitanalyse)
•
Code Coverage Analysis (Codeabdeckung)
Das Profiler-Front-End muss dabei nicht auf dem gleichem Rechner wie die VM laufen,
sondern kann aufgrund des unabhängigen Protokolls auf einem remote-Rechner ausgeführt
werden.
Für das Profiling kann nur genau ein Profiler Agent benutzt werden. Die gleichzeitige
Benutzung mehrerer verschiedener Agents zur Performancemessung eines Programms ist
nicht möglich. Die Auswahl des aktuellen Profiler Agents mit Angabe der zu testenden
Klasse erfolgt über die Befehlszeile
java -Xrunmyprofiler ToBeProfiledClass.
Eine Vielzahl von Java-Profilern basiert auf den Möglichkeiten des JVMPIs und nutzt diese.
Beispiele dafür sind Hyades [hyad] und Jakarta JMeter (jakarta.apache.org/jmeter/).
Zu beachten ist, dass sich durch das Profiling mit JVMPI in ungünstigen Fällen große
Laufzeitverschiebungen ergeben. Ursächlich dafür ist, dass unter Umständen jeder
Funktionsaufruf sowohl von benutzerdefinierten Funktionen als auch von JVM APIFunktionen ein Ereignis an den Profiler Agent meldet. Gravierende Beeinflussungen der
Laufzeit zeigen sich vor allem bei kleinen Funktionen, die sehr oft aufgerufen werden. Bei
längeren Berechnungen innerhalb einer Funktion minimiert sich der Fehlergrad des
Ergebnisses.
Mit Einführung von Java 5 wurde das bisherige JVMPI, das experimentellen Charakter hatte,
unter dem Namen Java Platform Profiling Architecture offiziell in das JDK aufgenommen.
Kolja Braden, Philipp Daubenschüz
7
Seminararbeit – Java Profiling
2.2 Profiling durch Instrumentierung
Eine weitere Möglichkeit Profilingdaten aufzuzeichnen bietet das Konzept der
Instrumentierung. Dabei wird Java-Quellcode vom Compiler in plattformunabhängigen
Bytecode übersetzt, der dann von der VM ausgeführt wird. Dieser Bytecode wird mit Zählern
und Zeitmessungen instrumentiert, um Ausführungshäufigkeit und Geschwindigkeit zu
bestimmen. Instrumentieren bedeutet hier, dass der compilierte Bytecode nachträglich
modifiziert wird. So wird an Stellen, die für die Auswertung interessant sind, vor allem am
Anfang und Ende von Methoden, zusätzlicher Code eingefügt. Es wird meist jede Methode
im zu testenden Programm einzeln instrumentiert, d. h. jede Methode wird gekapselt und ihre
Ausführungszeit wird gemessen.
Die Instrumentierung bietet den großen Vorteil, dass nicht auf das langsame JVMPI
zugegriffen werden muss. Unter Benutzung von Instrumentierung ist es möglich,
Ausführungsdauer und -Häufigkeit von benutzerdefinierten Methoden auszuwerten. Nicht
möglich ist es hier jedoch, Objekte und Threads zu überwachen. Insbesondere die
Nichterkennung von Threads kann in Multithread-Anwendungen zu erheblichen Fehlern
führen, da bei Ausführung einer Methode nicht die CPU-Zeit, sondern die absolut
vergangene Zeit gemessen wird. Eine weitere Schwachstelle ist, dass Java API – Aufrufe
nicht dokumentiert werden, d. h. unter Umständen kann die eigentliche PerformanzSchwachstelle, die z.B., wie in einem späteren Beispiel dargestellt, vom versehentlichen
Anlegen einer großen Anzahl von Objekten herrühren kann, nicht erkannt wird. Dadurch
dass sich das Profiling bei Anwendung des Instrumentierungverfahrens alleine auf die
Analyse von Ausführungsdauer und –Häufigkeit von Methoden beschränkt, ist eine
Speicheranalyse nicht möglich.
2.3 Profiling durch manuelle Zeitmessung
Für kleine Tests während der Entwicklungsphase werden vom Entwickler in der Regel
Testprogramme mit Konsolenausgabe geschrieben. Es können so Codefragmente überprüft
werden. Meistens wird mit der Konsolenausgabe abgeprüft, ob das Programm konsistent
arbeitet. Dabei kann schon während der Entwicklung von Codefragmenten eine
Performanceanalyse gemacht werden, indem mit Konsolenausgaben nicht nur die
Funktionalität überprüft wird, sondern mit einer in Java integrierten Zeitmessungsfunktion die
Ausführungsgeschwindigkeiten von verschiedenen Lösungsansätzen überprüft werden.
Kolja Braden, Philipp Daubenschüz
8
Seminararbeit – Java Profiling
So kann in einer frühen Entwicklungsphase durch den Programmierer der performantere
Algorithmus zur Lösung des gestellten Problems ausgewählt werden.
Java stellt für Zeitmessungen solcher Art die folgende Funktion zur Verfügung:
System.currentTimeMillis();
Diese Funktion gibt die Zeit in Millisekunden zurück, die seit dem 1.1.1970 vergangen ist.
Wenn man mit dieser Funktion sich die Zeit vor und nach der zu testenden Funktion
zurückgeben lässt kann man durch Subtraktion die Zeit, die zum Abarbeiten gebraucht
wurde berechnen.
Die Ergebnisse bei dieser Methode hängen davon ab, wie viele andere Prozesse sich auf
dem Rechner in Ausführung befinden. Es wird dabei die während der Ausführung absolut
vergangene Zeit gemessen. Wenn sich viele andere höher- priore Prozesse und Threads
momentan in der Ausführung befinden ergeben sich gewisse Abweichungen von der
Realität.
Hierzu ein Beispiel, bei dem zwei Möglichkeiten überprüft werden, einem String 10000 mal
ein Zeichen anzufügen:
public class Profiling {
public static void main( String args[] ){
int MAX = 10000;
long time1 = System.currentTimeMillis();
String s = "";
for ( int i = MAX; i-- > 0; )
s = s.concat( "t" );
time1 = System.currentTimeMillis() - time1;
long time2 = System.currentTimeMillis();
String t = "";
for ( int i = MAX; i-- > 0; )
t += "t";
time2 = System.currentTimeMillis()- time2;
System.out.println( "s.concat:
" + time1 + " ms" );
System.out.println( "t+=:
" + time2 + " ms" );
}
}
Kolja Braden, Philipp Daubenschüz
9
Seminararbeit – Java Profiling
In diesem Bespiel werden die Funktionen [string]. Concat([String]) mit der Funktion
[String]+=[String2] verglichen in dem beide 10000mal ausgeführt werden.
Die Funktion habe exakt die gleiche Funktionalität, der String der am Ende der
Funktionsschleifen ausgegeben wird ist exakt der gleiche. Die Art und Weise in dem die
Bibliotheken den String manipuliert haben sind unterschiedlich(mehr dazu im Kapitel 3.1
Hyades).
Man kann die Ausführungszeiten nicht als absolut betrachten, wie unten gezeigt. Die Zeiten
variieren je nach Auslastung des Systems, die zu dem momentanen Zeitpunkt bestand um
ca. 20%. Es wird bei jedem einzelnen Ausführen nicht exakt die gleiche Zeit gebraucht, um
die Funktionsschleifen des Beispiels auszuführen.
Es ist in jeder Ausführung deutlich zu erkennen, dass die Funktion Concate wesentlich
performanter ist als die gleiche Funktionalität mit dem Stringoperator +=.
Ecplise:
s.concat:
t+=:
230 ms
451 ms
Start von Konsole:
s.concat:
t+=:
201 ms
400 ms
Sehr ausgelastetes System:
s.concat:
t+=:
231 ms
480 ms
3 Profiling- Werkzeuge
3.1 Hyades
Der Name Hyades stammt von den Hyaden, einem der größten sichtbaren Sternhaufen.
Wissenschaftliche Bedeutung erlangten die Hyaden im Jahre 1919, als die Ablenkung des
von den Hyaden stammenden Lichts durch das Gravitationsfeld der Sonne gemessen
werden konnte. Damit konnte ein empirischer Beweis für die Richtigkeit der
Relativitätstheorie erbracht werden.
Kolja Braden, Philipp Daubenschüz
10
Seminararbeit – Java Profiling
Hyades [hyad] ist ein Plugin für Eclipse, das Profiling-Funktionalitäten zur Verfügung stellt.
Entwickelt wird Hyades vom Test & Performance Tools Platform Project (TPTP). Das TPTP
wurde 2002 von IBM ins Leben gerufen, an den aktuellen Releases sind unter anderem IBM,
SAP, Compuware und Intel beteiligt, die Hyades zur Performanceanalyse eigener
Softwareentwicklungen nutzen. Hyades stellt verschiedene Komponenten zur Verfügung:
•
•
Interoperable Informationsmodelle
-
z.B. UML2 (Codegenerierung aus UML-Modellen)
-
Eclipse Modelling Framework (EMF) basiert
Data Collection Framework und Laufzeitumgebung
-
Agent Controller
-
Entkopplung der Kommunikation zwischen System Under Test (SUT) und
Testclient
•
•
•
Test Tool Framework
-
automatisierte Testcases generieren
-
Analyse der Testergebnisse
-
generieren von benutzerdefinierten Reports
Profiling Framework
-
Analyse von Performance und Ressourcennutzung
-
Integriert in Eclipse GUI
-
Profiling entfernter und lokaler (Agent Controller) Systeme möglich
Log und Trace Frameworks
Kolja Braden, Philipp Daubenschüz
11
Seminararbeit – Java Profiling
-
Modell für Log- und Trace Events
-
Agent Controller als Laufzeitumgebung für die Event-Konsolidierung in
verteilten Systemen
Die Möglichkeiten der Performanzanalyse in Hyades basieren zu großen Teilen auf dem
Profiling Framework.
3.1.1 Installation
Voraussetzung für eine Installation ist ein aktuelles Java-SDK sowie eine installierte EclipseEntwicklungsumgebung.
Vor Installation von Hyades werden das Eclipse Modeling Framework (EMF) und der
Application Server „Agent Controller (RAC)“ benötigt. Die eigentliche Installation erfolgt, wie
bei Eclipse-Plugins üblich, durch Kopieren des Programms in das .../eclipse/plugin Verzeichnis. Der Agent Controller ist ein eigenständiger Application-Server.
3.1.2 Strategie und Bewertung
Der Agent Controller wird als externer eigenständiger Serverprozess betrieben. In ihm laufen
der zu testende Prozess und ein Hyades-Prozess, der diesen steuert und profiling-relevante
Daten zurückgibt. Vorteil hierbei ist, dass der Bytecode nicht verändert werden muss.
Hyades ist durch die Integration in Eclipse fast intuitiv zu bedienen. Im Gegensatz zu
anderen Profilern werden nicht nur Aufrufe von benutzerdefinierten Methoden ausgegeben,
sondern auch API – Methodenaufrufe bzw. Konstruktoren. Eine Schwachstelle von Hyades
ist, dass sich gewisse Unterschiede zwischen realer und gemessener Laufzeit ergeben,
abhängig von der Aufrufreihenfolge. Ursächlich dafür ist, dass Hyades auf dem JVMPI
basiert, woraus sich auch noch weitere, bereits oben erwähnte Ungenauigkeiten ergeben
können.
Kolja Braden, Philipp Daubenschüz
12
Seminararbeit – Java Profiling
3.1.3 Profiling mit Hyades
Als Beispiel für die Anwendung des Profilers soll hier ein Programm verwendet werden, das
schrittweise eine festgelegte Anzahl von Zeichen an einen String anfügt und das Ergebnis
auf der Konsole ausgibt.
public class prof1a {
public static String dots(int len) {
String ret = "";
for (int i = 0; i < len; ++i) {
ret += ".";
}
return ret;
}
public static void main(String[] args) {
String s = dots(10000);
System.out.println(s);
}
}
Kolja Braden, Philipp Daubenschüz
13
Seminararbeit – Java Profiling
Abbildung 3.1.1: Auswertung „+= String S“
Wie in Abbildung 3.1.1 zu erkennen ist, wird in jedem Schritt ein StringBuffer-Objekt
angelegt, das dann an den „Zielstring“ angefügt wird. Diese Erstellung vergleichsweise vieler
Objekte ist besonders Laufzeit- und, wie eine Memory-Analyse ergab, auch besonders
Speicher intensiv. Im Folgenden wird deshalb versucht, die gleiche Funktionalität mit
ressourcenschonenderen Methoden zu erreichen.
public class prof1b {
public static String dots(int len) {
StringBuffer sb = new StringBuffer(len + 10);
for (int i = 0; i < len; ++i) {
sb.append('.');
}
return sb.toString();
}
public static void main(String[] args) {
String s = dots(10000);
}
}
Kolja Braden, Philipp Daubenschüz
14
Seminararbeit – Java Profiling
Abbildung 3.1.2: Auswertung „ append“
Wie in Abbildung 3.1.2 zu erkennen, ist es gelungen, die Anzahl der erzeugten StringBufferObjekte um 99,9999% zu reduzieren. Dies schlägt sich im Vergleich zum ersten Beispiel in
wesentlich kürzerer Laufzeit und geringerem Speicherbedarf nieder.
3.1.4 Fazit
Im Vergleich zu anderen, insbesondere den mit Instrumentierung arbeitenden Profilern,
ermöglicht Hyades eine Vielzahl an Konfigurations- und Auswertemöglichkeiten. So können
hier nicht nur die konkret im Quellcode verankerten Objekte und Methoden bewertet werden,
sondern auch die darunterliegende JVM-Ebene. Die Bedienbarkeit von Hyades ist aufgrund
der Integration in Eclipse allen anderen getesteten Profiling- Programmen überlegen.
Ungenauigkeiten basieren auf dem oben beschriebenen Wirkungsprinzip des JVMPI.
Kolja Braden, Philipp Daubenschüz
15
Seminararbeit – Java Profiling
3.2 JRat
3.2.1 Installation
Das Programm JRat (Java Runtime Analysis Toolkit) ist ein freies Profiling-Werkzeug.
Bezogen werden kann das JRat jar-Archiv über [jrat]. Eine eigentliche Installation ist nicht
nötig, es handelt sich um eine direkt ausführbare jar- Datei.
3.2.2 Strategie
JRat benutzt keine in Java eingebauten Profiling-Methoden, sondern basiert auf dem
Konzept der Instrumentierung, das heißt es „infiziert“ bereits kompilierte class-Dateien. Wie
bereits oben beschrieben bedeutet dies, dass JRat vorkompilierte class-Dateien an
geeigneten Stellen abändert und Abhängigkeiten zu sich selbst (shiftone-jrat.jar) schafft.
Über diese Abhängigkeiten wird der Profiling- Vorgang gesteuert und kontrolliert. Während
des eigentlichen Testvorgangs werden Profilingdaten in eine Datei *.jrat geschreiben, die
dann von JRat ausgewertet werden kann.
3.2.3 Profiling mit JRat
Um bestimmte class-Dateien überprüfen zu können, ist es notwendig, dass das zu testende
Programm vor Beginn des Profilings bereits einmal übersetzt wurde. Das eigentliche
Infizieren erfolgt im darauf folgenden Schritt über die Schaltfläche Instruments->Inject Jar- or
Class-File bzw. für mehrere Dateien mit Instruments->Inject Directories Recursively.
Abbildung 3.2.1
Aufgrund der durch das Infizieren geschaffenen Abhängigkeiten zu JRat ist es für einen
erfolgreichen Testablauf unerlässlich, die Datei shiftone-jrat.jar in den Classpath der JVM zu
übernehmen.
JRat ermöglicht es, durch der JVM zu übergebende Parameter verschiedene Messmethoden
festzulegen, auf die im Folgenden kurz eingegangen werden soll. Es werden jeweils die
Ausgaben bei Test eines nach Quicksort sortierenden Programms dargestellt.
Kolja Braden, Philipp Daubenschüz
16
Seminararbeit – Java Profiling
•
-Djrat.factory=org.shiftone.jrat.provider.stats.StatMethodHandlerFactory
Es werden nur die manuell aufgerufenen Methoden mit Anzahl der Aufrufe und der
zugehörigen Laufzeit textuell dargestellt.
Abbildung 3.2.2: StatMethodHandlerFactory
Kolja Braden, Philipp Daubenschüz
17
Seminararbeit – Java Profiling
•
Djrat.factory=org.shiftone.jrat.provider.tree.TreeMethodHandlerFactory
Ausgegeben wird ein Methoden-Aufrufbaum. D.h. es wird ersichtlich gemacht, welche
Methode von wo aufgerufen wurde und wie lange die jeweilige Ausführungszeit war.
Besonders laufzeitintensive Methoden werden dabei farblich gekennzeichnet.
Abbildung 3.2.3: TreeMethodHandlerFactory
Kolja Braden, Philipp Daubenschüz
18
Seminararbeit – Java Profiling
•
Djrat.factory=org.shiftone.jrat.provider.log.LogMethodHandlerFactory
Hier wird eine Liste erstellt über den Zeitpunkt eines Methodeneintritts, den Zeitpunkt
des Wiederaustritts und die aktuelle Aufruftiefe.
Abbildung 3.2.4: LogMethodHandlerFactory
3.2.4 Fazit
JRat bietet Funktionalitäten, um einen groben Überblick über die ausgeführten Methoden
und die Anzahl ihrer Aufrufe zu erlangen. Auch die Ausführungszeit einer beliebigen
Methode wird hinreichend genau ausgegeben. Falls bestimmte Methoden unverhältnismäßig
viel Laufzeit benötigen, ist es allerdings oftmals nur unzureichend möglich, nachzuvollziehen,
Kolja Braden, Philipp Daubenschüz
19
Seminararbeit – Java Profiling
welcher Abschnitt der evtl. viel Code umfassenden Methode diese
Performanzeinschränkungen bewirkt. Im Gegensatz zu auf dem JVMPI basierenden
Profilern ist es hier außerdem nicht möglich, JVM- Systemaufrufe zu beobachten. Auch ist es
in JRat nicht möglich, Speicherbedarfsanalysen oder Analysen über den Grad der
Codeabdeckung durchzuführen.
3.3 HP- JMeter /Xrunhprof aus dem JDK
Das JDK von SUN beinhaltet einen Profiler „hprof“. Er wird mit dem Parameteraufruf xrunhprof bei der Ausführung eines Java- Programms gestartet. Mit Konsoleneingaben
folgender Form wird er aktiviert.
java –Xrunhprof [<option>=<value>, ...] [Programmname]
Mit diesem Profiler kann das Java- Programm bis zu 50-mal langsamer laufen, da der
logging Aufwand der Profilingergebnisse sehr hoch ist. Es können Optionen eingestellt
werden, in denen festgehalten ist wie der Profiler das zu testende Programm überprüfen soll,
z.B. :
cpu= times – hprof führt über die Zahl der Aufrüfe und deren Laufzeit Buch
cpu = samples – hprof wird in einem anderen Modus zu laufen, er arbeitet nicht als listener,
sondern holt in regelmäßigen Abständen, von der Virtuellen Machine die Stacktraces aller
Threads und speichert die Häufigkeit mit der es die verschiedenen Threads antrifft. In
diesem Modus ist die Ausführungsgeschwindigkeit nur noch zweimal langsamer.
file=<file> - damit kann explizit ein Dateiname angegeben werden, in den das Ergebnis
geschrieben wird.
Weitere Optionen:
java -Xrunhprof:help
Hprof usage: -Xrunhprof[:help]|[<option>=<value>, ...]
Option Name and Value Description
Default
--------------------- -----------
-------
heap=dump|sites|all
all
heap profiling
cpu=samples|times|old CPU usage
off
monitor=y|n
monitor contention
n
format=a|b
ascii or binary output
a
file=<file>
write data to file
java.hprof(.txt for ascii)
net=<host>:<port>
send data over a socket write to file
depth=<size>
stack trace depth
4
cutoff=<value>
output cutoff point
0.0001
Kolja Braden, Philipp Daubenschüz
20
Seminararbeit – Java Profiling
lineno=y|n
line number in traces
y
thread=y|n
thread in traces?
n
doe=y|n
dump on exit?
y
Example: java -Xrunhprof:cpu=samples,file=log.txt,
depth=3 FooClass
Xrunhprof erstellt als Ergebnis des Profilens eine txt- Datei. Diese Datei beinhaltet eine
Tabelle mit den CPU-Zeiten, in der Stacktraces als Nummer notiert sind.
CPU TIME (ms) BEGIN (total = 17314) Mon Oct 17 13:35:02 2005
rank
self
1
accum
count trace method
52.58%
52.58%
19993
301058
java.lang.AbstractStringBuilder.expandCapacity
2 21.17% 73.74%
10002 301056 java.lang.String.<init>
3
8.50% 82.25%
10000 301020 java.lang.String.concat
4
4.80% 87.05%
3 301023 java.lang.Object.wait
…..
Die Abfolge von Funktionsaufrüfen wird an anderer Stelle als die Stacktraces der
Ausgabedatei festgehalten.
THREAD
START
(obj=50000115,
id
=
200002,
name="HPROF
gc_finish
watcher", group="system")
THREAD START (obj=50000115, id = 200003, name="Signal Dispatcher",
group="system")
THREAD START (obj=50000115, id = 200001, name="main", group="main")
THREAD END (id = 200001)
THREAD
START
(obj=50000115,
id
=
200006,
name="DestroyJavaVM",
group="main")
THREAD END (id = 200006)
THREAD END (id = 200002)
TRACE 301058:
java.lang.AbstractStringBuilder.expandCapacity(<Unknown
Source>:Unknown line)
java.lang.AbstractStringBuilder.append(<Unknown Source>:Unknown
line)
java.lang.StringBuilder.append(<Unknown Source>:Unknown line)
_strings.main(_strings.java:Unknown line)
TRACE 301056:
Kolja Braden, Philipp Daubenschüz
21
Seminararbeit – Java Profiling
java.lang.String.<init>(<Unknown Source>:Unknown line)
java.lang.StringBuilder.toString(<Unknown Source>:Unknown line)
_strings.main(_strings.java:Unknown line)
TRACE 301020:
java.lang.String.concat(<Unknown Source>:Unknown line)
_strings.main(_strings.java:Unknown line)
TRACE 301023:
java.lang.Object.wait(<Unknown Source>:Unknown line)
java.lang.ref.Reference$ReferenceHandler.run(<Unknown
Source>:Unknown line)
TRACE 301053:
java.lang.AbstractStringBuilder.append(<Unknown Source>:Unknown
line)
java.lang.StringBuilder.append(<Unknown Source>:Unknown line)
_strings.main(_strings.java:Unknown line)
TRACE 301055:
…..
Kolja Braden, Philipp Daubenschüz
22
Seminararbeit – Java Profiling
3.3.1 Überblick über die Funktionalitäten
Mit HP-JMeter ist es möglich Profil-Dateien zu analysieren. Es steht zum kostenlosen
Download, auf der HP-Homepage, zur Verfügung. HP- JMeter bietet eine kostenlose und
einfache Möglichkeit ein Programm auf die Performance zu überprüfen. Der
Funktionsumfang, den HP JMeter bietet, hängt von der Benutzten Profilern ab.
Der HPJMeter unterstützt Profile Dateinen von folgenden Profilern:
Prof
Eprof
Xeprof
Xrunprof
Xrunhprof
Diese Profiler sind in den verschiedenen VirtualMaschins integriert und müssen
In dem hier dargestellten Beispiel wurde der Profiler „Xrunhprof“ des JDK 1.5 von java
benutzt und auf ein Programm mit verschiedenen Stringoperationen angewandt worden.
Beim Öffnen einer Log – Datei des Profilens erhält man vom Programm eone Übersich über
die gestesteten Software. Es werden Werte, wie z.B.; „Running
Kolja Braden, Philipp Daubenschüz
23
Seminararbeit – Java Profiling
time“ und „Number of Methods“ angezeigt.
Es kann mit dem HP-JMeter angezeigt werden, wie oft eine Methode aufgerufen wurde, und
wie viel Rechenzeit in den Methoden insgesamt Verbraucht wurde. Diese Funktionalitäten
kann man unter dem Menüpunkt „Metric“ finden.
Der Funktionsumfang des HP-JMeters hängt bei den Zeitfunktionalitäten von der
Profilingdatei ab.
Die Dateien werden von den integrierten Profilern mit unterschiedlich umfangreichen
Informationen gefüllt. Der Benutzer kann darüber hinaus mit unterschiedlichen Parametern,
die dem Profiler übergeben werden, den Informationsumfang der Ausgabedatei beeinflussen.
Kolja Braden, Philipp Daubenschüz
24
Seminararbeit – Java Profiling
Created Objects
Oft ist es hilfreich zu wissen, welche Objekte wie oft erzeugt werden, um
einzuschätzen, ob die vom Programm erzeugte Anzahl auch so vom Programmiere
gewünscht sind oder sich dort ein Optimierungsbedarf findet .
Um die Performance in dem Beispielprogramm zu verbessern, könnte statt der vielen String
ein Stringbuffer zur lösung des Problems gewählt werden. Mit dieser Maßnahme ließe sich
die gleiche Aufgabe mit wesentlich weniger Objekten bearbeiten.
Diese Ansicht ist wichtig, da das Erzeugen von Objekten Performances-lastig ist. In weiteren
Entwicklungsschritten ist zu überdenken, ob Objekte eingespart werden können.
Kolja Braden, Philipp Daubenschüz
25
Seminararbeit – Java Profiling
•
Call Graph
Die aufgerufenen Methoden lassen sich mit den HP-JMeter als hirarchische Struktur
darstellen. Diese Ansicht heißt Call Graph Tree.
Durch einen Doppelklick auf die entsprechende Methode kann man, die aufrufenden
Programmteile identifizieren.
Die Navigation durch den Graphen ist gewöhnungsbedürftig, es sind neben den
programmierten Aufrufen auch die Systemaufrufe der VirtualMaschine aufgeführt. Dadurch
ist der Call Tree sehr unübersichtlich.
Je nach Modus, in dem der Profiler gestartet wurde, sind die Daten nicht vollständig.
Bei dem Profiler Xrunhprof sind die Daten des CallTrees nicht vollständig, wenn man die
Option
-cpu=samples auswählt das dort nur in regelmäßigen Abständen der Stack der JVM
analysiert wird und für die Loggingdatei aufbereitet wird. Es kann dennoch erkannt werden,
welche Funktion von welchem Teil des zu testenden Programms aufgerufen wird.
Kolja Braden, Philipp Daubenschüz
26
Seminararbeit – Java Profiling
•
Thread Histogramm
Mit dem „Thread Histogramm“ können die Abläufe der Threads des getesteten Programms
visualisiert werden. In dem Beispiel sieht man den thread der Main-Funktion.
Es kann eine Darstellung als Histogramm per Doppelklick ausgewählt werden.
Das Diagramm ist je nach benutztem Profiler, und gewählten Optionen, mehr oder weniger
aussagekräftig.
3.3.2 Fazit
Das HP – JMeter ist ein kostenloser Profliler, an den die Erwartungen nicht zu hoch gesteckt
werden sollten. Es stehen relativ wenige Anzeigemöglichkeiten zur Verfügung. Die Anzahl
der Anzeigemöglichkeiten ist von dem benutzten Profiler abhängig.
Mit dem im Rahmen dieser Arbeit getesteten Xrunhprof kann man nicht unbedingt viele
brauchbare Informationen zur Performancesteigerung erhalten.
Die Benutzeroberfläche ist in einem unübersichtlichem Design so dass man nicht alle
Funktionen intuitiv findet, z.B. dass Sonderfunktionen durch Doppelklicken erscheinen.
Die Mitgeloggten Aufrufe von Biliotheksfunktionen machen die Oberfläche und die Anzeigen
zudem noch unübersichtlicher.
Gegenüber dem Lesen der Logging- Datei, die durch einen integrierten Profiler ertstellt
wurde ist es komfortabler dieses Tool zu benutzen. Mit anderen kostengünstigeren oder
kostenlosen Tools ist es möglich ein komfortableres Profiling durchzuführen.
Kolja Braden, Philipp Daubenschüz
27
Seminararbeit – Java Profiling
4 Bewertung von Performanceanalysen
Lösungen die bei der Entwicklung von Software erstellt wird hat oft das Problem der
Inperformance. Die Software arbeitet funktional korrekt, ist aber nicht durch lange
Wartezeiten, die der Benutzung autreten unkomfortabel für den Benutzer.
Es ist im Softwareentwicklungsprozess deshalb unbedingt notwendig, dass die Software
einem Refactoring unter Gesichtspunkten der Performance einem „Refactoring“ unterzogen
wird.
Zu diesem Zeitpunkt haben die Entwickler von Software zur Überprüfung der Funktionalität,
einen korrekt laufenden Prototypen mit dem die Funktionalitäten und Laufzeiten verglichen
werden können.
Einfache Zeitmessungen können mit Konsolenausgaben gemacht werden. Dies ist ungenau
und kann nur einen ersten Anhaltspunkt liefern. Eine bessere Möglichkeit stellt der Einsatz
vor sog. Profilern dar.
Profiler sind Entwicklungstools mit denen Zeitmessungen, Funktionsaufrufe, usw. gemachte
werden können. Jenach Tool stehen verschiedene Analysegrafiken zur Verfügung mit
denen, der Engpass in der zu testenden Software lokalisiert werden kann.
Im Rahmen dieser Arbeit sind verschiedene kostenlose Tools getestet und verglichen
worden. Die Tools sind sehr vielfältig, es sind Plugins erhältlich sowie Stand-Alone
Lösungen. Professionelle kostenpflichtige Tools sind nicht betrachtet worden.
Jedes Tool hat Vor- und Nachteile auf die eingegangen worden sind.
Beim Profiling mit den vorgestellten Tools entstehen systembedingt Messungenauigkeiten.
Hierbei gibt es im allgemeinen zwei Arten, wie die Messung sich negativ und ungenau auf
die Laufzeit des zu testenden Programms auswirken kann.
Zum einem ist ein Overhead möglich, der durch den Profiler entsteht und dadurch verlängert
sich die Laufzeit erheblich. Der Overhead entsteht dadurch, dass der Profiler die Messdaten
ermitteln muss.
Zum anderen entsteht ein Effekt der „Instrusion“ , d.h. dass auf die gleichen Resourcen
zugegriffen wird wie das wie das zu testende Programm. Der Profiler misst auch Effekte, die
er selber verursacht.
Es werden zwei Konzepte verfolgt, um diesen Effekt zu minimieren.
Beim Sampling wird die Laufzeit- Umgebung in festen Intervallen gestoppt und analysiert, in
welcher Methode sich das Programm zu dem Zeitpunkt befindet. So wird herausgefunden in
welcher Methode am meisten CPU- Zeit verbraucht wird.
Kolja Braden, Philipp Daubenschüz
28
Seminararbeit – Java Profiling
Es entsteht mit dieser Art zu messen.ein kleiner Overhead. Die Messdaten, der Call-Counts
und Call Graphs werden nicht mehr sehr genau abgebildet.
Mit dem Tracing wird bei jedem Methodenaufruf Daten ermittelt, z.B. die aufgerufene
Methode und wie viel Zeit in Ihr verbracht wurde. Wenn eine Messung auf diese Art
stattfindet werden die Call-Counts und Call Graphs relativ genau erfasst. Doch entsteht ein
Overhead der die Ergebnisse des Timing-Datas verändert.
Kolja Braden, Philipp Daubenschüz
29
Seminararbeit – Java Profiling
Anhang
A Beispielprogramme
Stringoperationen
public class _strings{
public static void main( String args[] )
{
int MAX = 10000;
// use static function
long time1 = System.currentTimeMillis();
String s = "";
for ( int i = MAX; i-- > 0; )
s = s.concat( "t" );
time1 = System.currentTimeMillis() - time1;
// use dynamic function
long time2 = System.currentTimeMillis();
String t = "";
for ( int i = MAX; i-- > 0; )
t += "t";
time2 = System.currentTimeMillis()- time2;
System.out.println( "1. s.concat:
" + time1 + " ms" );
System.out.println( "2. t+=
" + time2 + " ms" );
:
}
}
Quicksort Algorithmus (siehe Vorlesung Programmieren 2. Semester)
public class Anwendung{
public static void main (String args[]) {
//run Methode fest in dem Konstruktor verankert!
//"speicher" ist Speicher, mit dem Ausgaben realisiert werden sollen
long time1 = System.currentTimeMillis();
int [] a1={79, 4, 66, 78, 90, 1000, 45, 50, 1, 10};
Qsort testa1 = new Qsort(a1);
time1 = System.currentTimeMillis()- time1;
Kolja Braden, Philipp Daubenschüz
30
Seminararbeit – Java Profiling
long time2 = System.currentTimeMillis();
int [] a2={4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
Qsort testa2 = new Qsort(a2);
time2 = System.currentTimeMillis()- time2;
long time3 = System.currentTimeMillis();
int [] a3={4, 4, 4, 4, 4, 1, 4, 4, 4, 4};
Qsort testa3 = new Qsort(a3);
time3 = System.currentTimeMillis()- time3;
long time4 = System.currentTimeMillis();
int[] a4= {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
Qsort testa4= new Qsort(a4);
time4 = System.currentTimeMillis()- time4;
long time5 = System.currentTimeMillis();
int[] a5= {50, 49, 48, 47, 46, 45, 44, 43, 42, 41,
40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21,
20, 19, 18, 17, 16, 15, 14, 13, 12, 11,
10,
9,
8,
7,
6,
5,
4,
3,
2,
1};
Qsort testa5= new Qsort(a5);
time5 = System.currentTimeMillis()- time5;
System.out.println(
"nr1: "+time1+"ms\n nr2: "+time2+"ms\n nr3: "+time3+"ms\n
nr4: "+time4+"ms\n nr5: "+time5+"ms\n"
);
}
}
Kolja Braden, Philipp Daubenschüz
31
Seminararbeit – Java Profiling
B Quellenangaben
[Ulle02] Java ist auch eine Insel
von Christian Ullenboom
Broschiert - 1239 Seiten - Galileo Press
Erscheinungsdatum: Oktober 2002
ISBN: 389842331X
[Flan02] Java in a Nutshell
von David Flanagan
Broschiert - 1104 Seiten - O'Reilly
Erscheinungsdatum: November 2002
ISBN: 389721332X
[Tamm04]Michael Tamm ;iX 4/2004, S.42
[Dude04]Der Duden, Bd.1 : Duden Die deutsche Rechtschreibung
Bibliographisches Institut, Mannheim
ISBN: 3411040130
[AdAd03] Leistungsanalyse von Java Anwendungen mit HPJMeter
Björn Adam, Michael Adams, 11/03
[Stre05]Java-Performancemessung, Martin Strenge, 2005
[Hage05] Java Performance Messungen, Johannes Hagen, 2005
Websites:
http://java.sun.com/developer/onlineTraining/Programming/JDCBook/perf3.html
[hyad]
[jrat] http://jrat.sourceforge.net
Kolja Braden, Philipp Daubenschüz
32
Herunterladen
Explore flashcards