Pourquoi StringBuilder#append (int) est-il plus rapide en Java 7 qu'en Java 8?

While investigating for a little debate W. R. T. en utilisant "" + n et Integer.toString(int) pour convertir un entier primitif en chaîne, j'ai écrit ce JMH microbenchmark:

@Fork(1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class IntStr {
    protected int counter;


    @GenerateMicroBenchmark
    public String integerToString() {
        return Integer.toString(this.counter++);
    }

    @GenerateMicroBenchmark
    public String stringBuilder0() {
        return new StringBuilder().append(this.counter++).toString();
    }

    @GenerateMicroBenchmark
    public String stringBuilder1() {
        return new StringBuilder().append("").append(this.counter++).toString();
    }

    @GenerateMicroBenchmark
    public String stringBuilder2() {
        return new StringBuilder().append("").append(Integer.toString(this.counter++)).toString();
    }

    @GenerateMicroBenchmark
    public String stringFormat() {
        return String.format("%d", this.counter++);
    }

    @Setup(Level.Iteration)
    public void prepareIteration() {
        this.counter = 0;
    }
}

Je l'ai lancé avec les options JMH par défaut avec les deux VM Java qui existent sur ma machine Linux (Mageia à jour 64 bits, Intel I7-3770 CPU, 32 Go RAM). La première JVM a été celle fournie avec Oracle JDK 8u5 64 bits:

java version "1.8.0_05"
Java(TM) SE Runtime Environment (build 1.8.0_05-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)

avec cette JVM j'ai eu à peu près ce que j'attendais:

Benchmark                    Mode   Samples         Mean   Mean error    Units
b.IntStr.integerToString    thrpt        20    32317.048      698.703   ops/ms
b.IntStr.stringBuilder0     thrpt        20    28129.499      421.520   ops/ms
b.IntStr.stringBuilder1     thrpt        20    28106.692     1117.958   ops/ms
b.IntStr.stringBuilder2     thrpt        20    20066.939     1052.937   ops/ms
b.IntStr.stringFormat       thrpt        20     2346.452       37.422   ops/ms

i. e. l'utilisation de la classe StringBuilder est plus lente en raison des frais généraux supplémentaires liés à la création de l'objet StringBuilder et à l'ajout d'une chaîne de caractères vide. L'utilisation de String.format(String, ...) est encore plus lente, d'un ordre de grandeur.

le compilateur fourni par distribution, d'autre part, est basé sur OpenJDK 1.7:

java version "1.7.0_55"
OpenJDK Runtime Environment (mageia-2.4.7.1.mga4-x86_64 u55-b13)
OpenJDK 64-Bit Server VM (build 24.51-b03, mixed mode)

les résultats ici étaient intéressant :

Benchmark                    Mode   Samples         Mean   Mean error    Units
b.IntStr.integerToString    thrpt        20    31249.306      881.125   ops/ms
b.IntStr.stringBuilder0     thrpt        20    39486.857      663.766   ops/ms
b.IntStr.stringBuilder1     thrpt        20    41072.058      484.353   ops/ms
b.IntStr.stringBuilder2     thrpt        20    20513.913      466.130   ops/ms
b.IntStr.stringFormat       thrpt        20     2068.471       44.964   ops/ms

pourquoi StringBuilder.append(int) apparaît-il tellement plus vite avec cette JVM? L'examen du code source de la classe StringBuilder n'a rien révélé de particulièrement intéressant - la méthode en question est presque identique à Integer#toString(int) . Chose intéressante, ajouter le résultat de Integer.toString(int) (le stringBuilder2 microbenchmark) ne semble pas être plus rapide.

cet écart de rendement pose-t-il un problème avec le harnais d'essai? Ou est-ce que mon OpenJDK JVM contient des optimisations qui affecteraient ce code (anti) - pattern particulier?

EDIT:

pour une comparaison plus directe, J'ai installé Oracle JDK 1.7u55:

java version "1.7.0_55"
Java(TM) SE Runtime Environment (build 1.7.0_55-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.55-b03, mixed mode)

les résultats sont similaires à ceux D'OpenJDK:

Benchmark                    Mode   Samples         Mean   Mean error    Units
b.IntStr.integerToString    thrpt        20    32502.493      501.928   ops/ms
b.IntStr.stringBuilder0     thrpt        20    39592.174      428.967   ops/ms
b.IntStr.stringBuilder1     thrpt        20    40978.633      544.236   ops/ms

il semble que ce soit un problème plus général de Java 7 par rapport à Java 8. Peut-être que Java 7 avait des optimisations de chaînes plus agressives?

EDIT 2 :

pour plus d'exhaustivité, voici les options VM liées aux chaînes de caractères pour ces deux JVM:

pour Oracle JDK 8u5:

$ /usr/java/default/bin/java -XX:+PrintFlagsFinal 2>/dev/null | grep String
     bool OptimizeStringConcat                      = true            {C2 product}
     intx PerfMaxStringConstLength                  = 1024            {product}
     bool PrintStringTableStatistics                = false           {product}
    uintx StringTableSize                           = 60013           {product}

Pour OpenJDK 1.7:

$ java -XX:+PrintFlagsFinal 2>/dev/null | grep String
     bool OptimizeStringConcat                      = true            {C2 product}        
     intx PerfMaxStringConstLength                  = 1024            {product}           
     bool PrintStringTableStatistics                = false           {product}           
    uintx StringTableSize                           = 60013           {product}           
     bool UseStringCache                            = false           {product}   

l'option UseStringCache a été supprimée dans Java 8 sans aucun remplacement, donc I le doute qui fait toute la différence. Les autres options semblent avoir les mêmes paramètres.

EDIT 3:

une comparaison side-by-side du code source des classes AbstractStringBuilder , StringBuilder et Integer du fichier src.zip ne révèle rien de noteworty. En dehors d'un grand nombre de changements cosmétiques et de la documentation, Integer a maintenant un certain soutien pour les entiers non signés et StringBuilder a a été légèrement remanié pour partager plus de code avec StringBuffer . Aucun de ces changements ne semble affecter les chemins de code utilisés par StringBuilder#append(int) , bien que j'ai pu manquer quelque chose.

une comparaison du code d'assemblage généré pour IntStr#integerToString() et IntStr#stringBuilder0() est beaucoup plus intéressante. La disposition de base du code généré pour IntStr#integerToString() était similaire pour les deux JVM, bien que Oracle JDK 8u5 semble être plus agressif W. R. T. en ligne certains appels à l'intérieur de la Integer#toString(int) du code. Il y avait une correspondance claire avec le code source Java, même pour quelqu'un avec une expérience minimale d'assemblage.

le code d'assemblage pour IntStr#stringBuilder0() était radicalement différent. Le code généré par Oracle JDK 8u5 était à nouveau directement lié au code source Java - je pouvais facilement reconnaître la même mise en page. Au contraire, le code généré par OpenJDK 7 était presque méconnaissable à l'œil non formé (comme le mien). Le new StringBuilder() l'appel a été apparemment supprimé, tout comme la création du tableau dans le constructeur StringBuilder . De plus, le plugin de démontage n'a pas pu fournir autant de références au code source que dans JDK 8.

je suppose que c'est soit le résultat d'un passage d'optimisation beaucoup plus agressif dans OpenJDK 7, soit plus probablement le résultat de l'insertion de code de bas niveau écrit à la main pour certaines opérations StringBuilder . Je ne sais pas pourquoi cette optimisation ne se produire dans ma mise en œuvre JVM 8 ou pourquoi les mêmes optimisations n'ont pas été mises en œuvre pour Integer#toString(int) dans JVM 7. Je suppose que quelqu'un qui connaît les parties du code source de JRE devrait répondre à ces questions...