© ESB Professional/Shutterstock.com
Performanceoptimierung mit Microbenchmarks

Wer nicht weiß, was er misst, misst Mist!


Performanceoptimierung ist ein sehr spannendes Feld in der Softwareentwicklung. Es muss nicht immer gleich bis runter zu Assembler gehen, Java selbst bietet jede Menge Möglichkeiten, Code so zu schreiben, dass er sehr performant wird.

Erst einmal soll der Frage auf den Grund gegangen werden, was nun ein Microbenchmark ist und wann sein Einsatz sinnvoll ist.

Ein Microbenchmark ist ein kleiner künstlicher Benchmark, der dazu gedacht ist, eine Methode oder einen Algorithmus zu testen und verschiedene Szenarien und/oder Implementierungen miteinander zu vergleichen. Bei einem Microbenchmark geht es darum, die Performance eines kleinen, ganz bestimmten Codeteils zu messen, im Gegensatz zu ganzen Programmen oder Projekten. Das ist vor allem dann sinnvoll, wenn einzelne Methoden oder Codeabschnitte getestet werden sollen, die auf einem kritischen Pfad liegen. Beispiele sind die Verwendung von verschiedenen Datenstrukturen, der Vergleich von Sortiermethoden und Ähnliches. Für ein paar Fingerübungen sind Fragen à la Stack Overflow „Was ist schneller, X oder Y?“ ein guter Start.

Gerade in diesen Situationen ist es unerlässlich, bestimmte Implementierungen miteinander zu vergleichen. Wenn es dabei um kleine Codeabschnitte geht, die auch noch sehr schnell durchlaufen, wird es allerdings auch schnell kompliziert. Jede Messung beeinflusst das Ergebnis, und jeder kleine Fehler verfälscht das Ergebnis massiv.

Je kleiner die Zeiteinheiten werden, desto größer wird der störende Effekt von Umgebungsfaktoren, die sich nicht immer kontrollieren lassen. Es kann beispielsweise sein, dass die CPU gerade heruntergetaktet ist und erst auf volle Leistung umschalten muss. Im Hintergrund startet vielleicht gerade der Download eines Softwareupdates, oder der Virenscanner beginnt seine täglichen Aufgaben. Im Rahmen der Messungen sollten solche Faktoren so gut es geht ausgeschaltet werden. Sämtliche Programme und Services, die nicht absolut notwendig sind, sollten beendet werden.

Die Clubregeln des Microbenchmarks

Ein Problem mit Microbenchmarks ist die Tatsache, dass das Problem umso komplizierter wird, je mehr man sich damit auseinandersetzt und je geringer die Ausführungszeiten werden. Daher die folgenden Regeln:

  1. Traue niemals den Ergebnissen

  2. Benchmarks lügen mehr als Statistiken

  3. Überprüfe immer deine Ergebnisse

Wenn die Ergebnisse eines Microbenchmarks nicht plausibel erscheinen, sind sie es meist auch nicht. In diesem Fall sollte man nach Fehlern im Benchmark Ausschau halten; dazu gleich mehr.

Regel 2 zielt darauf ab, dass man natürlich Benchmarks in jede Richtung beeinflussen kann, ob absichtlich oder unabsichtlich. Gerade wenn jemand einfach behauptet, dass X schneller ist als Y, schaut euch den dazugehörigen Benchmark genau an und führt ihn am besten selbst aus. Wenn kein Benchmark vorhanden ist, schreibt selbst einen, wenn möglich, um die Aussagen zu überprüfen. Schaut euch auch eure eigenen Ergebnisse genau an und stellt die Frage, ob ihr tatsächlich das Richtige getestet habt. Schaltet während des Tests möglichst alle Störfaktoren ab und lasst den Test am besten noch auf anderen Computern laufen. Der einfachste Ansatz ist der in Listing 1 dargestellte.

Listing 1

List<Integer> aList = new ArrayList<>();
//fill list with values
  long t1 = System.currentTimeMillis();
  Collections.sort(aList);
  long t2 = System.currentTimeMillis();
  System.out.println("Time Required using Collections.sort() "+(t2-t1)+"ms");

Das erste Argument gegen den Ansatz ist, dass der Overhead durch die Messung in Relation zu einem einzigen Methodenaufruf zu hoch ist. Selbst ein so einfacher Aufruf wie System.nanoTime() ist für eine Operation im Laufzeitbereich von 2-3 ms immer noch recht teuer. Weiterhin ist der Name irreführend, da die Präzision der Operation nicht im einstelligen Nanosekundenbereich liegt. Die beste Auflösung, die man bekommen kann, liegt um die 30 ns, und das ist auch noch abhängig vom Betriebssystem. Wichtig ist an diesem Punkt noch zu erwähnen, dass System.nanoTime() nichts mit der Systemuhrzeit zu tun hat. Diese Methode sollte man nur zur Messung von Zeitdifferenzen verwenden, nicht für einen Vergleich mit der realen Uhrzeit.

Jetzt optimieren wir den Ansatz, indem die Operation in einer Schleife viele Male durchgeführt und dann der Mittelwert errechnet wird. Hierbei gilt es zu beachten, dass die Listen vor der Schleife initialisiert werden, da wir sonst mehr messen als wir eigentlich vorhaben. Der Code ist in Listing 2 nur verkürzt dargestellt, auf GitHub [1] findet ihr ein vollständiges Beispiel.

Listing 2

int loopCount = 1_000_000;
List<List<Integer>> allLists = new ArrayList<>();
//Hier müssen jetzt alle Listen erzeugt und mit Werten gefüllt werden
long start = System.nanoTime();​
for (int i = 0; i < loopCount; i++) {
  Collections.sort(allLists.get(i));
}  
long end = System.nanoTime();​
System.out.println("Duration: " + (end - start)/loopCount);

Es werden nur zwei Messpunkte genommen, das heißt, der Overhead durch die Messung ist sehr gering. Jetzt wird es richtig interessant: Warum wird die Operation plötzlich schneller? Auf meinem Testsystem ging die durchschnittliche Zeit zum Sortieren einer Liste von ~38 ms auf ~4 ms herunter. Hier kommt die erste sehr wichtige Optimierung durch die JVM zum Tragen, der JIT-Compiler. Dieser sorgt dafür, dass die Teile des Codes, die sehr häufig ausgeführt werden, auch möglichst gut optimiert werden. Hierfür greift der JIT-Compiler auf eine Vielzahl von Möglichkeiten zurück [2], unter anderem Loop Unrolling, Dead Code Elimination und Method Inlining. Hinzu kommen die Seiteneffekte durch die JVM. Die größten sind hier der JIT-Compiler und der Garbage Collector.

JIT-Compiler

Der JIT-Compiler optimiert den Code, während er läuft. Für die Messung ist interessant, dass sämtliche Optimierungen bereits vorgenommen wurden, bevor die Messdaten erhoben werden. Nur dann bekommen wir Daten, die auch etwas mit dem realen Anwendungsfall zu tun haben. Das Problem ist, dass die Optimierungen erst nach mehreren tausend Durchläufen abgeschlossen sind. Deshalb ist es wichtig, vor jeder Messung die JVM „aufzuwärmen“. Per Default muss ein Codestück 10 000mal aufgerufen werden, bevor die erste Optimierung durch den JIT gestartet wird. Das ist auch der Grund, warum uns im Produktivbetrieb nicht die Performance im kalten Zustand interessiert...

headline from sands settings