Java 8 du flux: pourquoi parallèle flux est plus lent?

Je suis à jouer avec Java 8 de cours d'eau et ne peut pas comprendre les résultats que j'obtiens. J'ai 2 core CPU (Intel i73520M), Windows 8 64 bits et 64 bits de Java 8 update 5. Je suis en train de faire simple carte au-dessus de flux/courant parallèle de Chaînes et a trouvé que la version parallèle est un peu plus lent.

Function<Stream<String>, Long> timeOperation = (Stream<String> stream) -> {
  long time1 = System.nanoTime();
  final List<String> list = 
     stream
       .map(String::toLowerCase)
       .collect(Collectors.toList());
  long time2 = System.nanoTime();
  return time2 - time1;
};

Consumer<Stream<String>> printTime = stream ->
  System.out.println(timeOperation.apply(stream) / 1000000f);

String[] array = new String[1000000];
Arrays.fill(array, "AbabagalamagA");

printTime.accept(Arrays.stream(array));            //prints around 600
printTime.accept(Arrays.stream(array).parallel()); //prints around 900

Ne devrait pas la version parallèle être plus rapide, compte tenu du fait que j'ai 2 cœurs de PROCESSEUR?
Quelqu'un pourrait-il me donner un indice pourquoi version parallèle est plus lent?

InformationsquelleAutor Eugene Loy | 2014-04-19

132

Il y a plusieurs questions se passe ici en parallèle, comme elle l'avait fait.

La première est que la résolution d'un problème en parallèle implique toujours d'effectuer plus de travail que de le faire de façon séquentielle. Frais généraux sont impliqués de diviser le travail entre plusieurs threads et de l'adhésion ou de fusionner les résultats. Des problèmes comme la conversion de chaînes courtes afin de diminuer les cas sont assez petits qu'ils sont en danger d'être submergé par le parallèle fractionnement des frais généraux.

Le deuxième problème est que l'analyse comparative programme Java est très subtil, et il est très facile d'obtenir des résultats étranges. Deux questions sont à la compilation JIT et l'élimination du code mort. Court de repères souvent terminer avant ou au cours de compilation JIT, ils ne sont donc pas de mesure de débit de pointe, et en effet, ils pourraient être en mesure de l'équipe elle-même. Lorsque la compilation se produit est quelque peu non-déterministe, donc il peut provoquer des résultats varient énormément en tant que bien.

Pour les petits, synthétique repères, la charge de travail souvent calcule des résultats qui sont jetés. Les compilateurs JIT sont assez bien à la détection et l'élimination de code qui ne produisent pas de résultats, qui sont utilisés n'importe où. Ce n'est probablement pas qui se passe dans cette affaire, mais si vous bricoler avec d'autres synthétique de travail, il peut certainement se produire. Bien sûr, si le JIT élimine l'indice de référence de la charge de travail, il rend le test inutile.

Je recommande fortement d'utiliser un référentiel comme JMH au lieu de la main, le laminage à un de vos propres. JMH a des équipements pour aider à éviter les courants d'analyse comparative des pièges, y compris les présentes, et il est assez facile de configurer et d'exécuter. Voici votre référence converti pour utiliser JMH:
```
package com.stackoverflow.questions;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.*;

public class SO23170832 {
    @State(Scope.Benchmark)
    public static class BenchmarkState {
        static String[] array;
        static {
            array = new String[1000000];
            Arrays.fill(array, "AbabagalamagA");
        }
    }

    @GenerateMicroBenchmark
    @OutputTimeUnit(TimeUnit.SECONDS)
    public List<String> sequential(BenchmarkState state) {
        return
            Arrays.stream(state.array)
                  .map(x -> x.toLowerCase())
                  .collect(Collectors.toList());
    }

    @GenerateMicroBenchmark
    @OutputTimeUnit(TimeUnit.SECONDS)
    public List<String> parallel(BenchmarkState state) {
        return
            Arrays.stream(state.array)
                  .parallel()
                  .map(x -> x.toLowerCase())
                  .collect(Collectors.toList());
    }
}
```
J'ai couru ce à l'aide de la commande:
```
java -jar dist/microbenchmarks.jar ".*SO23170832.*" -wi 5 -i 5 -f 1
```
(Les options indiquent cinq warmup itérations, cinq référence itérations, et une fourche JVM.) Au cours de son exécution, JMH émet beaucoup de messages détaillés, que j'ai ramené. Le résumé des résultats sont comme suit.
```
Benchmark                       Mode   Samples         Mean   Mean error    Units
c.s.q.SO23170832.parallel      thrpt         5        4.600        5.995    ops/s
c.s.q.SO23170832.sequential    thrpt         5        1.500        1.727    ops/s
```
De constater que les résultats sont dans l'ops par seconde, donc il semble que le parallèle était environ trois fois plus rapide que l'ordre d'exécution. Mais ma machine n'a que deux cœurs. Hmmm. Et l'erreur moyenne par run est en fait plus grande que la moyenne d'exécution! WAT? Quelque chose de louche se passe ici.

Cela nous amène à un troisième point. En regardant de plus près la charge de travail, nous pouvons voir qu'il alloue un nouvel objet String pour chaque entrée, et il recueille également les résultats dans une liste, ce qui implique beaucoup de réaffectation et de la copie. Je suppose que cela va résulter en une bonne quantité de la collecte des ordures. Nous pouvons voir cela en exécutant de nouveau le test de la cg messages activé:
```
java -verbose:gc -jar dist/microbenchmarks.jar ".*SO23170832.*" -wi 5 -i 5 -f 1
```
Cela donne des résultats tels que:
```
[GC (Allocation Failure)  512K->432K(130560K), 0.0024130 secs]
[GC (Allocation Failure)  944K->520K(131072K), 0.0015740 secs]
[GC (Allocation Failure)  1544K->777K(131072K), 0.0032490 secs]
[GC (Allocation Failure)  1801K->1027K(132096K), 0.0023940 secs]
# Run progress: 0.00% complete, ETA 00:00:20
# VM invoker: /Users/src/jdk/jdk8-b132.jdk/Contents/Home/jre/bin/java
# VM options: -verbose:gc
# Fork: 1 of 1
[GC (Allocation Failure)  512K->424K(130560K), 0.0015460 secs]
[GC (Allocation Failure)  933K->552K(131072K), 0.0014050 secs]
[GC (Allocation Failure)  1576K->850K(131072K), 0.0023050 secs]
[GC (Allocation Failure)  3075K->1561K(132096K), 0.0045140 secs]
[GC (Allocation Failure)  1874K->1059K(132096K), 0.0062330 secs]
# Warmup: 5 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: com.stackoverflow.questions.SO23170832.parallel
# Warmup Iteration   1: [GC (Allocation Failure)  7014K->5445K(132096K), 0.0184680 secs]
[GC (Allocation Failure)  7493K->6346K(135168K), 0.0068380 secs]
[GC (Allocation Failure)  10442K->8663K(135168K), 0.0155600 secs]
[GC (Allocation Failure)  12759K->11051K(139776K), 0.0148190 secs]
[GC (Allocation Failure)  18219K->15067K(140800K), 0.0241780 secs]
[GC (Allocation Failure)  22167K->19214K(145920K), 0.0208510 secs]
[GC (Allocation Failure)  29454K->25065K(147456K), 0.0333080 secs]
[GC (Allocation Failure)  35305K->30729K(153600K), 0.0376610 secs]
[GC (Allocation Failure)  46089K->39406K(154624K), 0.0406060 secs]
[GC (Allocation Failure)  54766K->48299K(164352K), 0.0550140 secs]
[GC (Allocation Failure)  71851K->62725K(165376K), 0.0612780 secs]
[GC (Allocation Failure)  86277K->74864K(184320K), 0.0649210 secs]
[GC (Allocation Failure)  111216K->94203K(185856K), 0.0875710 secs]
[GC (Allocation Failure)  130555K->114932K(199680K), 0.1030540 secs]
[GC (Allocation Failure)  162548K->141952K(203264K), 0.1315720 secs]
[Full GC (Ergonomics)  141952K->59696K(159232K), 0.5150890 secs]
[GC (Allocation Failure)  105613K->85547K(184832K), 0.0738530 secs]
1.183 ops/s
```
Remarque: les lignes commençant par # sont normales JMH lignes de sortie. Tout le reste sont des GC messages. C'est le premier des cinq de chauffe itérations, qui précède de cinq référence itérations. Le GC messages a continué dans la même veine pendant le reste de la itérations. Je pense qu'il est sûr de dire que les performances mesurées est dominé par GC frais généraux et que les résultats présentés ne doivent pas être cru.

À ce stade, il est difficile de savoir quoi faire. Ceci est purement synthétique de la charge de travail. Il implique clairement que très peu de CPU de temps à faire le travail réel par rapport à la répartition et de la copie. Il est difficile de dire ce que vous êtes vraiment essayer de mesurer ici. Une approche serait de trouver un travail qui est dans un certain sens, plus "réel". Une autre approche serait de changer le tas et GC paramètres pour éviter GC lors de l'indice de référence exécuter.
- +1 très approfondie de la réponse et un bon tutoriel sur la façon de exécuter correctement et interpréter un micro de référence!
- Je sais très ancien comme dans le thread, mais de le lire (a) je peux dire que j'ai beaucoup appris - comme microbenchmarking et (b) j'ai une question : en disant " je pense qu'il est sûr de dire que les performances mesurées est dominé par GC-dessus de la tête, comment exactement ce qui est présenté à partir de données? quelqu'un peut-il donner plus de détails?
- Le principal est que l'erreur moyenne est plus grande que le résultat réel. Cela signifie que le temps d'une itération varie considérablement de l'un à l'autre. Idéalement, vous voulez toutes les itérations d'être proche ensemble, avec un écart de seulement quelques pour cent. J'ai déterminé que la GC était à l'origine de la variance en permettant GC journalisation. La façon dont l'analyse comparative des œuvres est qu'un timestamp est prise au début d'une itération et de nouveau à la fin d'une itération. La différence de temps est assumé la quantité de temps CPU consommée par la charge de travail que vous êtes en mesure de.
- Mais si il y a beaucoup de GC, ce n'est pas le cas. Parfois, la demande thread est bloqué en attente pour le GC, pour libérer de la mémoire. Si cela se produit pendant une référence itération, le temps pour cette itération comprend à la fois le travail réel plus le temps d'attente pour GC. Dans JMH chaque itération est par défaut à 1 seconde. À la recherche, à la GC de journal que j'ai posté, certains de la GC cycles a pris de 0,10 à 0,13$, soit 0,51 secondes. L'ajout de la GC temps est une fraction significative de 1 seconde. Ainsi, que 1-deuxième itération est probable que plus de la moitié pris par GC. C'est ce que je voulais dire par "dominé."
InformationsquelleAutor Stuart Marks

Quand vous faites des repères, vous devriez prêter attention à la compilation JIT, et que la durée comportements peuvent changer, en fonction du montant de JIT code compilé les chemins d'accès. Si j'ajoute une phase de préchauffage de votre programme de test, la version parallèle est un peu plus rapide que la version séquentielle. Voici les résultats:

Warmup...
Benchmark...
Run 0:  sequential 0.12s  -  parallel 0.11s
Run 1:  sequential 0.13s  -  parallel 0.08s
Run 2:  sequential 0.15s  -  parallel 0.08s
Run 3:  sequential 0.12s  -  parallel 0.11s
Run 4:  sequential 0.13s  -  parallel 0.08s

Le fragment de code suivant contient le code source complet que j'ai utilisé pour ce test.

public static void main(String... args) {
String[] array = new String[1000000];
Arrays.fill(array, "AbabagalamagA");
System.out.println("Warmup...");
for (int i = 0; i < 100; ++i) {
sequential(array);
parallel(array);
}
System.out.println("Benchmark...");
for (int i = 0; i < 5; ++i) {
System.out.printf("Run %d:  sequential %s  -  parallel %s\n",
i,
test(() -> sequential(array)),
test(() -> parallel(array)));
}
}
private static void sequential(String[] array) {
Arrays.stream(array).map(String::toLowerCase).collect(Collectors.toList());
}
private static void parallel(String[] array) {
Arrays.stream(array).parallel().map(String::toLowerCase).collect(Collectors.toList());
}
private static String test(Runnable runnable) {
long start = System.currentTimeMillis();
runnable.run();
long elapsed = System.currentTimeMillis() - start;
return String.format("%4.2fs", elapsed / 1000.0);
}

InformationsquelleAutor nosid

8

Utilisation de plusieurs threads pour traiter vos données de configuration initiale des coûts, par exemple, l'initialisation du pool de threads. Ces coûts peuvent l'emporter sur les gains provenant de l'utilisation de ces threads, en particulier si le moteur d'exécution est déjà très faible. En outre, si il y a un conflit, par exemple, d'autres threads en cours d'exécution, processus d'arrière-plan, etc., les performances de traitement parallèle peut encore diminuer.

Ce problème n'est pas nouveau pour le traitement en parallèle. Cet article donne quelques détails dans la lumière de Java 8 parallel() et un peu plus de choses à prendre en compte: http://java.dzone.com/articles/think-twice-using-java-8

InformationsquelleAutor joe776

Vous devez vous connecter pour publier un commentaire.