Mesure de performance Java

Je fais un certain Java comparaison des performances entre mes cours, et je me demandais si il y avait une sorte de Java Cadre de Performance pour rendre l'écriture de mesure du rendement de code plus facile?

I. e, ce que je fais maintenant est d'essayer de mesurer l'effet qu'a-t-elle de disposer d'une méthode comme "synchronisée", comme dans PseudoRandomUsingSynch.nextInt() par rapport à l'utilisation d'un AtomicInteger comme mon "synchroniseur".

Donc je suis en train d'essayer de mesurer combien de temps il faut pour générer des nombres entiers à l'aide de 3 fils de l'accès à une méthode synchronisée en boucle pour dire 10000 fois.

Je suis sûr qu'il ya une bien meilleure façon de faire cela. Pouvez-vous svp m'éclairer? 🙂

public static void main( String [] args ) throws InterruptedException, ExecutionException {
    PseudoRandomUsingSynch rand1 = new PseudoRandomUsingSynch((int)System.currentTimeMillis());
    int n = 3;
    ExecutorService execService = Executors.newFixedThreadPool(n);

    long timeBefore = System.currentTimeMillis();
    for(int idx=0; idx<100000; ++idx) {
        Future<Integer> future = execService.submit(rand1);
        Future<Integer> future1 = execService.submit(rand1);
        Future<Integer> future2 = execService.submit(rand1);

        int random1 = future.get();
        int random2 = future1.get();
        int random3 = future2.get();

    }
    long timeAfter = System.currentTimeMillis();
    long elapsed = timeAfter - timeBefore;
    out.println("elapsed:" + elapsed);
}

la classe

public class PseudoRandomUsingSynch implements Callable<Integer> {
private int seed;

public PseudoRandomUsingSynch(int s) { seed = s; }

public synchronized int nextInt(int n) {
    byte [] s = DonsUtil.intToByteArray(seed);
    SecureRandom secureRandom = new SecureRandom(s);
    return ( secureRandom.nextInt() % n );
}

@Override
public Integer call() throws Exception {
    return nextInt((int)System.currentTimeMillis());
}
}

Ce qui concerne

source d'informationauteur portoalet

11

En ignorant la question de savoir si un microbenchmark est utile dans votre cas (Stephen C' les points sont très valide), je tiens à souligner:

Tout d'abord, ne pas écouter les gens qui disent: "il n'est pas difficile'. Oui, microbenchmarking sur une machine virtuelle avec compilation JIT est difficile. C'est en fait très difficile à obtenir pertinentes et utiles sur les chiffres d'un microbenchmark, et toute personne qui prétend qu'il n'est pas difficile, c'est soit un supergenius ou de faire le mal. 🙂

Deuxièmement, oui, il y a un peu de ces cadres de autour de. Une peine de regarder (la pensée, c'est à un stade très précoce de la pré-release de la scène) est Étrierpar Kevin Bourrillion et Jesse Wilson de Google. On dirait vraiment impressionnant de quelques début de la regarde.
8

Plus de micro-analyse comparative des conseils - micro repères rarement vous dire ce que vous avez vraiment besoin de savoir ... ce qui est la façon rapide d'une véritable application va s'exécuter.

Dans votre cas, j'imagine que vous êtes à essayer de comprendre si votre demande un meilleur rendement à l'aide d'un objet Atomique que l'utilisation synchronisée ... ou vice-versa. Et la vraie réponse est que il est probable qu'il dépend de facteurs qu'un micro-benchmark ne peut pas mesurer. Des choses comme la probabilité de conflit, combien de temps verrous, le nombre de threads et les transformateurs, et la quantité de l'algorithmique des travaux nécessaires pour rendre atomique de mise à jour d'une solution viable.

MODIFIER la réponse à cette question.

donc, il y a un moyen pour que je puisse mesurer tous ces probabilité de conflit, les verrous détenus durée, etc ?

En théorie oui. Une fois que vous avez mis en œuvre la totalité de la demande, il est possible de l'instrument de mesure de ces choses. Mais cela ne vous donne pas votre réponse, car il n'y a pas un modèle prédictif, vous pouvez brancher ces chiffres en donner la réponse. Et d'ailleurs, vous avez déjà mis en œuvre l'application.

Mais mon point n'était pas que la mesure de ces facteurs permet de prédire les performances. (Il n'est pas!) C'était plutôt qu'un micro-benchmark ne pas vous permettre de prédire les performances soit.

En réalité, la meilleure approche est de mettre en œuvre l'application selon votre intuition, et ensuite utiliser le profilage comme base pour déterminer les réels problèmes de performances.
4

Ces gars-là ont conçu un bon JVM de la méthode de mesure de sorte que vous ne serez pas vous tromper avec de faux numéros, puis l'a publié comme un script Python de sorte que vous pouvez ré-utiliser leur ingéniosité -

Statistiquement Rigoureuse Java Évaluation de la Performance (pdf document)
3

Vous voudrez probablement aller la boucle dans la tâche. Comme il est que vous venez de commencer tous les threads et presque immédiatement, vous êtes de retour à thread unique.

D'habitude microbenchmarking conseils: prévoir un échauffement. Ainsi que la moyenne, la déviation est intéressant. Utilisation System.nanoTime au lieu de System.currentTimeMillis.

Spécifique à ce problème est de savoir comment le fils de lutte. Avec un grand nombre de prétendant fils, cas boucles peuvent effectuer gaspillage de travail. La création d'un SecureRandom est probablement coûteux, et donc peut System.currentTimeMillis dans une moindre mesure. Je crois SecureRandom devrait déjà être thread-safe, si elle est utilisée correctement.
3

OpenJDK les gars ont développé un outil d'évaluation appelé JMH:

http://openjdk.java.net/projects/code-tools/jmh/

Cette offre assez facile pour l'installation de framework, et il y a un couple d'échantillons montrant comment l'utiliser.

http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/

Rien ne peut vous empêcher de l'écriture de l'indice de référence de mal, mais ils ont fait un excellent travail lors de l'élimination de la non-erreurs évidentes (comme le faux partage entre les threads, la prévention de l'élimination du code mort, etc).
1

En bref, vous êtes donc à la recherche d'une "Java unité de l'outil de test des performances"?

Utilisation JUnitPerf.

Mise à jour: pour le cas où il n'est pas encore tout à fait clair: il prend également en charge simultanées (multithreading) de test. Voici un extrait du chapitre "LoadTest" du lien ci-dessus qui contient un exemple de code:
Par exemple, pour créer un test de charge de
10 utilisateurs simultanés avec chaque utilisateur
l'exécution de l'
ExampleTestCase.testOneSecondResponse()
méthode pour 20 itérations, et avec un 1
seconde de délai entre l'ajout de
les utilisateurs, utilisation:
```
int users = 10;
int iterations = 20;
Timer timer = new ConstantTimer(1000);
Test testCase = new ExampleTestCase("testOneSecondResponse");
Test repeatedTest = new RepeatedTest(testCase, iterations);
Test loadTest = new LoadTest(repeatedTest, users, timer);
```

Vous devez vous connecter pour publier un commentaire.