Échapper à l'analyse en Java

Autant que je sache, la JVM utilise échapper à l'analyse de certaines performances optimisations comme de verrouillage de grossissement et de verrouillage de l'élision.
Je suis intéressé si il y a une possibilité pour la JVM de décider que tout objet particulier peut être alloué sur la pile à l'aide échapper à l'analyse.

Certains ressources me faire penser que j'ai raison. Est-il Jvm que faire?

  • Documentation Oracle: Après s'être échappée de l'analyse, le serveur compilateur élimine scalaire remplaçable par l'objet des allocations et des verrous associés à partir de code généré. Le serveur compilateur élimine également les verrous pour tous les non-à l'échelle mondiale s'échapper des objets. IL NE REMPLACE PAS UN TAS DE RÉPARTITION AVEC UNE ALLOCATION DE PILE.
  • Il ne remplace pas un tas de répartition avec une allocation de pile POUR les NON-à l'échelle MONDIALE s'ÉCHAPPER des OBJETS.
  • la question a été posée en 2009 et ma réponse était en 2013 🙂
  • laissez le commentaire-être le cas, afin d'éviter la confusion considérant de plus nouvelles versions JDK.
InformationsquelleAutor Denis Bazhenov | 2009-04-21
  1. 5

    Je ne le pense pas échapper à l'analyse de l'allocation de pile. exemple:

    public class EscapeAnalysis {

    private static class Foo {
        private int x;
        private static int counter;

        public Foo() {
            x = (++counter);
        }
    }
    public static void main(String[] args) {
        System.out.println("start");
        for (int i = 0; i < 10000000; ++i) {
            Foo foo = new Foo();
        }

        System.out.println(Foo.counter);
    }
}

    avec -server -verbose:gc -XX+DoEscapeAnalysis:

    commencer 
[GC 3072K->285K(32640K), 0.0065187 sec] 
[GC 3357K->285K(35712K), 0.0053043 sec] 
[GC 6429K->301K(35712K), 0.0030797 sec] 
[GC 6445K->285K(41856K), 0.0033648 sec] 
[GC 12573K->285K(41856K), 0.0050432 sec] 
[GC 12573K->301K(53952K), 0.0043682 sec] 
[GC 24877K->277K(53952K), 0.0031890 sec] 
[GC 24853K->277K(78528K), 0.0005293 sec] 
[GC 49365K->277K(78592K), 0.0006699 sec] 
10000000

    Aurait JDK 7 prend en charge l'allocation de pile.

    InformationsquelleAutor benmmurphy
  2. 92

    Avec cette version de java -XX:+DoEscapeAnalysis résultats en moins de gc activité et 14x une exécution plus rapide.

    $ java -version
java version "1.6.0_14"
Java(TM) SE Runtime Environment (build 1.6.0_14-b08)
    Java HotSpot(TM) Client VM (build 14.0-b16, mixed mode, sharing)

$ uname -a
Linux xxx 2.6.18-4-686 #1 SMP Mon Mar 26 17:17:36 UTC 2007 i686 GNU/Linux

    Sans échapper à l'analyse,

    $ java -server -verbose:gc EscapeAnalysis|cat -n
     1  start
     2  [GC 896K->102K(5056K), 0.0053480 secs]
     3  [GC 998K->102K(5056K), 0.0012930 secs]
     4  [GC 998K->102K(5056K), 0.0006930 secs]
   --snip--
   174  [GC 998K->102K(5056K), 0.0001960 secs]
   175  [GC 998K->102K(5056K), 0.0002150 secs]
   176  10000000

    À échapper à l'analyse,

    $ java -server -verbose:gc -XX:+DoEscapeAnalysis EscapeAnalysis
start
[GC 896K->102K(5056K), 0.0055600 secs]
10000000

    Le temps d'exécution réduit de manière significative à échapper à l'analyse. Pour ce faire, la boucle a été changé pour 10e9 itérations,

    public static void main(String [] args){
    System.out.println("start");
    for(int i = 0; i < 1000*1000*1000; ++i){
        Foo foo = new Foo();
    }
    System.out.println(Foo.counter);
}

    Sans échapper à l'analyse,

    $ time java -server EscapeAnalysis
start
1000000000

real    0m27.386s
user    0m24.950s
sys     0m1.076s

    À échapper à l'analyse,

    $ time java -server -XX:+DoEscapeAnalysis EscapeAnalysis
start
1000000000

real    0m2.018s
user    0m2.004s
sys     0m0.012s

    De manière à échapper à l'analyse de l'exemple a couru environ 14x plus rapide que les non-escape exécution de l'analyse.

    InformationsquelleAutor Janek Bogucki
  3. 2

    Échapper à l'analyse est vraiment très jolie, mais elle n'est pas complète obtenir de prison carte gratuite. si vous avez un dynamiquement la taille de la collection à l'intérieur d'un objet, l'évasion d'analyse ne sera PAS basculer du segment de pile. Par exemple:

    public class toEscape {
   public long l;
   public List<Long> longList = new ArrayList<Long>();
}

    Même si cet objet est créé dans une méthode et PAS du tout à s'échapper d'une syntaxiques point de vue, le compilateur ne marque pas cela pour s'échapper. Je suspecte parce que longList n'est pas vraiment délimité dans la taille d'un pur point de vue syntaxique, et il pourrait souffler votre pile potentiellement. Donc je crois qu'il faut un laissez-passer sur cette affaire. J'ai testé ce où la longList était vide et encore il a causé des collections dans un simple micro de référence.

    • C'est parce que longList est alloué dans toEscapes constructeur. Le constructeur ne semble pas être intégrées, de sorte que le longList de référence s'échappe donc. Le type de l'objet n'a pas d'importance dans ce cas.
    InformationsquelleAutor Mike Ceruti