Test de performances

Objectifs du chapitre :

• Comprendre l'importance des tests de performances dans le développement logiciel.
• Introduction à JMH (Java Microbenchmark Harness) pour réaliser des benchmarks de code Java.
• Apprendre à configurer et à utiliser JMH pour mesurer les performances de votre code.
• Explorer les bonnes pratiques pour les tests de performances.

11.1 Introduction aux tests de performances

Les tests de performances sont essentiels pour s'assurer que le logiciel répond aux exigences de rapidité et d'efficacité. Ils permettent de mesurer la vitesse, la scalabilité et la stabilité du code sous diverses charges et conditions. Ces tests identifient les goulots d'étranglement et les parties du code qui nécessitent une optimisation.

11.2 Introduction à JMH (Java Microbenchmark Harness)

JMH est une bibliothèque développée par l'équipe OpenJDK pour réaliser des microbenchmarks précis et fiables en Java. Les microbenchmarks mesurent les performances de petites portions de code de manière isolée, ce qui permet d'obtenir des résultats reproductibles et significatifs.

Caractéristiques principales de JMH :

• Précision et reproductibilité des mesures.
• Support pour diverses options de configuration et de mesure.
• Intégration facile avec les projets Java.

Installation de JMH :

Pour utiliser JMH dans votre projet, ajoutez la dépendance suivante à votre fichier pom.xml (pour Maven) ou build.gradle (pour Gradle).

Pour Maven :

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.36</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.36</version>
    <scope>provided</scope>
</dependency>

Pour Gradle :

dependencies {
    implementation 'org.openjdk.jmh:jmh-core:1.36'
    annotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.36'
}

11.3 Création d'un benchmark avec JMH

Pour créer un benchmark avec JMH, suivez les étapes suivantes :

1. Créer une classe de benchmark :

   • Annoter la classe avec @State pour indiquer qu'elle contient des benchmarks.

2. Écrire des méthodes de benchmark :

   • Annoter chaque méthode de benchmark avec @Benchmark.

3. Configurer les paramètres de benchmark (optionnel) :

   • Utiliser des annotations comme @Warmup, @Measurement, et @Fork pour configurer les benchmarks.

Exemple complet :

Classe de benchmark (MyBenchmark.java) :

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;

import java.util.concurrent.TimeUnit;

@State(org.openjdk.jmh.annotations.Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class MyBenchmark {

    @Benchmark
    @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
    @Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
    @Fork(1)
    public void testMethod() {
        // Code à mesurer
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
    }
}

11.4 Exécution des benchmarks

Pour exécuter les benchmarks JMH, utilisez la ligne de commande pour compiler et exécuter les benchmarks :

Compiler les benchmarks :

Exécuter les benchmarks :

11.5 Interprétation des résultats

Les résultats des benchmarks JMH fournissent des informations détaillées sur les performances de votre code, telles que :

• Temps moyen d'exécution : Le temps moyen pris par la méthode de benchmark pour s'exécuter.
• Écart-type : La variation des temps d'exécution.
• Distribution des temps d'exécution : Une répartition des temps d'exécution pour comprendre les comportements anormaux.

11.6 Bonnes pratiques pour les tests de performances

1. Isoler le code testé :

   • Assurez-vous que les benchmarks testent uniquement le code que vous souhaitez mesurer et évitez les dépendances externes qui peuvent affecter les résultats.

2. Utiliser des warmups :

   • Utilisez des périodes de warmup pour permettre à la JVM de s'optimiser avant de mesurer les performances.

3. Répéter les mesures :

   • Répétez les benchmarks plusieurs fois pour obtenir des résultats stables et significatifs.

4. Analyser les résultats :

   • Interprétez soigneusement les résultats des benchmarks pour identifier les goulots d'étranglement et les opportunités d'optimisation.

5. Éviter les optimisations prématurées :

   • Concentrez-vous sur les optimisations après avoir identifié les problèmes de performances réels à l'aide des benchmarks.

Résumé du chapitre :

• Les tests de performances sont cruciaux pour s'assurer que le logiciel répond aux exigences de rapidité et d'efficacité.
• JMH est une bibliothèque puissante pour réaliser des microbenchmarks précis en Java.
• Configurer et exécuter des benchmarks avec JMH est simple et fournit des résultats détaillés sur les performances de votre code.
• Suivre les bonnes pratiques pour les tests de performances garantit des mesures précises et des optimisations efficaces.