Benchmarking en hotspotoptimalisatie

Welkom bij benchmarking en hotspotoptimalisatie! In deze les leer je hoe je de prestaties van je code meet en gebieden voor verbetering vindt.

Benchmarking is het meten van de prestatiekenmerken van een programma of een specifiek onderdeel ervan. Meestal houdt dit in dat je de code meerdere keren uitvoert en statistieken verzamelt, zoals uitvoeringstijd en geheugengebruik.

Je denkt misschien te weten welk onderdeel van je code traag is, maar intuïtie kan je vaak misleiden. Daarom is de stelregel ‘Niet raden, maar meten!’ zo belangrijk bij het afstellen van prestaties.

Benchmarking levert objectieve, empirische gegevens op waarmee je knelpunten kunt vinden. Zonder deze gegevens loop je het risico tijd te besteden aan het optimaliseren van de verkeerde onderdelen van je toepassing, met weinig of geen prestatiewinst als gevolg.

Voor betrouwbare benchmarking in Clojure is de bibliotheek criterium de feitelijke standaard. Deze voorkomt veelvoorkomende valkuilen van microbenchmarking op de JVM, zoals:

• Opwarmfase: Code meerdere keren uitvoeren zodat de JIT-compiler van de JVM deze kan optimaliseren.
• Garbagecollection: De verstoring ervan tijdens metingen beperken.
• Statistische analyse: Betrouwbare meetwaarden leveren, zoals gemiddelde, mediaan en standaardafwijking.

Om Criterium te gebruiken, moet je het eerst als afhankelijkheid aan je project toevoegen (bijvoorbeeld in project.clj of deps.edn). Vervolgens kun je de macro bench uit criterium.core gebruiken.

De macro bench neemt een expressie aan en voert deze herhaaldelijk uit terwijl de prestaties worden gemeten. Bekijk een eenvoudig voorbeeld:

Wanneer je een Criterium-benchmark uitvoert, geeft deze gedetailleerde statistieken weer. Dit zijn de belangrijkste meetwaarden waarop je moet letten:

• Gemiddelde: De gemiddelde uitvoeringstijd.
• Mediaan: De middelste uitvoeringstijd wanneer de waarden zijn gesorteerd; deze is minder gevoelig voor uitschieters.
• Standaardafwijking: Geeft de variatie in de resultaten aan. Lager is beter.
• Iteraties per seconde: Hoe vaak de code per seconde kan worden uitgevoerd.

Richt je op het gemiddelde en de mediaan voor de gebruikelijke prestaties, en op de standaardafwijking om de consistentie te controleren.

Een hotspot is een gedeelte van de code dat onevenredig veel uitvoeringstijd gebruikt. Met benchmarking kun je deze gebieden precies lokaliseren.

Vaak begin je met een bredere benchmark (bijvoorbeeld een volledige functie). Als die traag is, ga je verder door kleinere, belangrijke gedeelten binnen die functie te benchmarken totdat je het exacte knelpunt vindt.

Pas gerichte optimalisaties toe zodra je een hotspot hebt gevonden. Veelgebruikte strategieën zijn:

• Toewijzingen verminderen: Minder nieuwe objecten maken, vooral in krappe lussen.
• Primitieven gebruiken: Java-primitieve typen (bijvoorbeeld int en long) benutten voor numerieke berekeningen via typeaanduidingen of directe Java-interoperabiliteit.
• Memoization: Resultaten van kostbare pure functies cachen.
• Algoritme kiezen: Efficiëntere algoritmen of datastructuren selecteren.

Vergelijk twee manieren om een lange reeks getallen op te tellen. De eerste gebruikt standaardfuncties van Clojure; de tweede gebruikt directe Java-interoperabiliteit met primitieve typen voor mogelijk betere prestaties in een hotspot.

Let op hoe typeaanduidingen (^long) en toegang tot Java-arrays (aget) de JVM kunnen aansturen om efficiëntere code voor numerieke taken te maken.

Voor betrouwbare benchmarkresultaten:

• Code isoleren: benchmark alleen het specifieke gedeelte dat je wilt onderzoeken.
• Consistente omgeving: voer benchmarks uit op een consistent systeem met zo min mogelijk achtergrondprocessen.
• Realistische gegevens: gebruik gegevens die het werkelijke gebruik van je toepassing weerspiegelen.
• Meerdere uitvoeringen: Criterium handelt dit af, maar houd er rekening mee dat één uitvoering zelden genoeg is.

Voer altijd opnieuw een benchmark uit nadat je wijzigingen hebt aangebracht, om verbeteringen te controleren.

In deze les heb je een goed begrip gekregen van benchmarken en hotspotoptimalisatie:

• We hebben geleerd dat benchmarken objectieve gegevens oplevert om prestatieknelpunten te identificeren.
• We hebben criterium verkend als de standaardbibliotheek van Clojure voor benchmarken en bekeken hoe je de resultaten interpreteert.
• Je hebt gezien hoe je hotspots identificeert en gerichte optimalisatiestrategieën toepast, waaronder het benutten van Java-primitieven.

Onthoud: meet altijd voordat je optimaliseert!