• 27 Dec 09
  

  Ajit

  java gc jvm tuning performance garbage development optimization options

• 17 Dec 09
  

  W.W. Webster

  sun.com

  computing swengi java

  • The Java^TM 2 Platform Standard Edition (J2SE^TM platform) is used for a wide variety of applications
    from small applets on desktops to web services on large servers. In the J2SE
    platform version 1.4.2 there were four garbage collectors from which to choose
    but without an explicit choice by the user the serial garbage collector was
    always chosen. In version 5.0 the choice of the collector is based on the class
    of the machine on which the application is started.
  • This “smarter choice” of the garbage collector is generally better but is not
    always the best. For the user who wants to make their own choice of garbage
    collectors, this document will provide information on which to base that choice.
    This will first include the general features of the garbage collections and
    tuning options to take the best advantage of those features. The examples are
    given in the context of the serial, stop-the-world collector. Then specific
    features of the other collectors will be discussed along with factors that
    should considered when choosing one of the other collectors.
• 23 Nov 09
  

  Rajeev K
  • Documentation

    
    

    Tuning Garbage Collection with the 5.0 Java[tm] Virtual Machine

• 09 Sep 09
  

  Matt Mize

  jvm gc

  • 
• 18 Jun 09
  

  jing zhu

  turning garbage collection gc

  • e goal of ergonomics is to provide good performance
    from the JVM with a minimum of command line tuning. Ergonomics
    attempts to match the best selection of

    
    
    • 
      

      Garbage collector

      
      
    • 
      

      Heap size

      
      
    • 
      

      Runtime compiler

  • Garbage collectors make assumptions about the way applications use
    objects, and these are reflected in tunable parameters that can be
    adjusted for improved performance without sacrificing the power of
    the abstraction
  • 29 more annotations...
  • • Efficient collection is made possible by focusing on
      the fact that a majority of objects "die young".
    • To optimize for this scenario, memory is managed in generations,
      or memory pools holding objects of different ages.
    • The heap size
      parameters selected by ergonomics plus the features of the adaptive
      size policy are meant to provide good performance for server
      applications.
    • The throughput garbage
      collector is meant to be used by large applications
    • The default arrangement of generations (for all collectors
      with
      the exception of the throughput collector) looks something like this.
    • One
      survivor space is empty at any time,
    • The permanent
      generation is special because it holds data needed by the
      virtual machine to describe objects that do not have an equivalence
      at the Java language level.
    • Throughput is the percentage of total time not spent in
      garbage collection, considered over long periods of time.
    • Footprint
      is the working set of a process, measured in pages and cache lines
    • Throughput and footprint are best measured using metrics
      particular to the application
    • The command line argument -verbose:gc
      prints information at every collection.
    • The
      numbers
      before and after the arrow

    • 325407K->83000K (in
      the first line)

      
      

      
      
      

      
      

      indicate the combined size of live objects before and after
      garbage collection, respectively.

    • (776768K)(in
      the first line)

      
      

      
      
      

      
      

      is the total available space, not counting the space in the
      permanent generation, which is the total heap minus one of
      the
      survivor spaces

    • Sizing
      the Generations
    • Some of the parameters are ratios of one part of the heap to
      another.
    • Total Heap
    • Since collections occur when generations fill up, throughput
      is
      inversely proportional to the amount of memory available. Total
      available memory is the most important factor affecting garbage
      collection performance.
    • The rules of thumb for server
      applications are:
    • Setting -Xms
      and -Xmx to the same
      value increases predictability by removing the most important sizing
      decision from the virtual machine
    • The bigger the young
      generation, the less often minor collections occur
    • -XX:NewRatio=3
      means that the ratio between the young and tenured
      generation is 1:3.
    • Young
      Generation Guarantee
    • The rules of thumb for server applications are:
    • The throughput collector will throw an out-of-memory exception
      if
      too much time is being spent doing garbage collection
    • For most applications the permanent generation is not
      relevant to garbage collector performance. However, some applications
      dynamically generate and load many classes. For instance, some
      implementations of JSP^TM pages do
      this. If necessary, the maximum permanent generation size can
      be increased with MaxPermSize.
    • Some applications interact with garbage collection by using
      finalization
    • Relying on garbage collection to
      manage resources other than memory is almost always a bad idea.
    • One of the most commonly encountered uses of explicit garbage
      collection occurs with RMI's distributed garbage collection (DGC).
      Applications using RMI refer to objects in other virtual machines.
      Garbage can't be collected in these distributed applications without
      occasional local collection, so RMI forces periodic full collection.
      The frequency of these collections can be controlled with properties.
      For example,
• 17 Jun 09
  

  Jared Whiklo

  Web Development Java Garbage Collection

• 14 May 09
  

  vivek saini

  he lifetimes of objects.

  jvm gc garbage collection

  • he uncommitted space is labeled
    "virtual" in this figure.
  • The throughput collector uses multiple threads to
    execute a minor collection
  • 1 more annotations...
  • • Turning on the throughput collector should
      just make the minor collection pauses shorte
• 30 Mar 09
  

  Lorenzo G

  garbage collector gc java

• 12 Dec 08
  

  Eric Wang

  java jvm tuning garbage collection permanent permsize

  • The permanent
    generation is special because it holds data needed by the
    virtual machine to describe objects that do not have an equivalence
    at the Java language level.
  • For example objects describing classes
    and methods are stored in the permanent generation
  • 1 more annotations...
  • • For most applications the permanent generation is not
      relevant to garbage collector performance. However, some applications
      dynamically generate and load many classes. For instance, some
      implementations of JSP^TM pages do
      this. If necessary, the maximum permanent generation size can
      be increased with MaxPermSize.
• 09 Dec 08
  

  Serge Slipchenko

  Tuning Garbage Collection with the 5.0 Java[tm] Virtual Machine

  Garbage_Collection Java

• 07 Oct 08
  

  Roberto Franchini

  java optimization performance profiling reference

• 05 Oct 08
  

  Satish Burnwal

  jvm gc tuning

  • To optimize for this scenario, memory is managed in generations,
    or memory pools holding objects of different ages. Garbage collection
    occurs in each generation when the generation fills up.
  • When the tenured generation needs to be
    collected there is a major collection that is often much
    slower because it involves all live objects.
  • 9 more annotations...
  • • The serial garbage collector is meant to be
      used by small applications. Its default parameters were designed to
      be effective for most small applications. The throughput garbage
      collector is meant to be used by large applications. The heap size
      parameters selected by ergonomics plus the features of the adaptive
      size policy are meant to provide good performance for server
      applications.
    • The command line argument -verbose:gc
      prints information at every collection.
    • The uncommitted space is labeled
      "virtual" in this figure.
    • Since collections occur when generations fill up, throughput
      is
      inversely proportional to the amount of memory available.
    • The throughput collector: this collector uses a
      parallel
      version of the young generation collector. It is used if the -XX:+UseParallelGC option is
      passed on the command line. The tenured generation collector is
      the same as the serial collector.
    • The concurrent low pause collector: this collector
      is
      used if the -Xincgc™ or -XX:+UseConcMarkSweepGC is passed
      on the command line. The concurrent collector is used to collect the tenured
      generation and does most of the collection concurrently with the
      execution of the application. The application is paused for short
      periods during the collection. A parallel version of the young
      generation copying collector is used with the concurrent collector.
    • Use the throughput collector when you want to improve the
      performance of your application with larger numbers of processors. In
      the serial collector garbage collection is done by one thread, and
      therefore garbage collection adds to the serial execution time of the
      application. The throughput collector uses multiple threads to
      execute a minor collection and so reduces the serial execution time
      of the application. A typical situation is one in which the
      application has a large number of threads allocating objects. In such
      an application it is often the case that a large young
      generation is needed.
    • The throughput collector is a generational collector similar
      to
      the serial collector but with multiple threads used to do the minor
      collection. The major collections are essentially the same as with
      the serial collector. By default on a host with N CPUs, the
      throughput collector uses N garbage collector threads in the
      minor collection.
    • The throughput collector can be enabled by using command line
      flag
      -XX:+UseParallelGC.
      The
      number of garbage collector threads can be controlled with the
      ParallelGCThreads
      command
      line option (-XX:ParallelGCThreads=<desired
      number>).
• 03 Oct 08
  

  Matt Weaver

  java gc

• 28 Jul 08
  

  fulvius longhi

  • 5.1 When to
    Use the Throughput Collector

    
    

    Use the throughput collector when you want to improve the
    performance of your application with larger numbers of processors.

• 26 Jun 08
  

  XO Q

  java jvm performance garbage gc

• 06 May 08
  

  Srikant Jakilinki

  with the 5.0 Java[tm] Virtual Machine

• 

  sven duzont

  java,garbage collector,tuning
  
  
  
  
  
  
  
  
  
  
  
  

  java garbage collector tuning

• 30 Apr 08
  

  Po Chui

  java performance tuning gc jvm java5

• 16 Oct 07
  

  Emmanuel Hugonnet

  Tuning Garbage Collection with the 5.0 JavaTM Virtual Machine: memory model for Java

  jdk1.5 reference performance

• 28 Aug 07
  

  nori nori

  gc jvm

• 09 Aug 07
  

  aweeraman

  General

• 30 Jul 07
  

  DJHell .

  garbage collection Java Java 5 Leistung tuning development

• 26 Jul 07
  

  Olifante *

  gc java jvm hotspot jit optimization tuning parameters

• 02 Jul 07
  

  Navneet Kumar

  Garbage-Collection JVM Performance sun GC Tuning Java

  • Efficient collection is made possible by focusing on
    the fact that a majority of objects "die young".
  • Use the concurrent low pause collector if your application
    would
    benefit from shorter garbage collector pauses and can afford to share
    processor resources with the garbage collector when the application
    is running. Typically applications which have a relatively large set
    of long-lived data (a large tenured generation), and run on
    machines with two or more processors tend to benefit from the use of
    this collector.
• 25 Apr 07
  

  Qing Du

  Java

• 24 Jan 07
  

  kanzen zen

  Java

  • serial
• 12 Dec 06
  

  Elliot

  imported:del.icio.us java jvm performance tuning

• 21 Nov 06
  

  Joao Vitor Guimaraes

  garbagecollection java

• 02 Nov 06
  

  J Feng
  • -XX:+PrintGCTimeStamps
• 28 Sep 06
  

  arnold reuser

  default heap xms xmx

  • -XX:MinHeapFreeRatio=

    
    
    
    

    40

    
    
    
    

    
    
    

    
    
    
    
    

    -XX:MaxHeapFreeRatio=

    
    
    
    

    70

    
    
    
    
    

    -Xms

    
    
    
    

    3670k

    
    
    
    
    

    -Xmx

    
    
    
    

    64m

  • Unless you have problems with pauses, try granting as
    much
    memory as possible to the virtual machine. The default size (64MB) is
    often too small.

    
    

    Setting -Xms
    and -Xmx to the same
    value increases predictability by removing the most important sizing
    decision from the virtual machine. On the other hand, the virtual
    machine can't compensate if you make a poor choice.

    
    

    Be sure to increase the memory as you increase the
    number of
    processors, since allocation can be parallelized.

• 30 Aug 06
  

  Raghu Rajagopalan

  gc java memory_leak

• 25 Aug 06
  

  Tobi B

  performance tips java gc JEE furl

• 07 Aug 06
  

  Brian Caruso

  gc java

• 11 Jul 06
  

  Alex Choi

  development gc java jvm language programming tuning vm 개발 언어 자바 튜닝 프로그래밍

• 27 Dec 05
  

  David Ziegler
• 08 Dec 05
  

  Wytze Koopal

  Tuning Garbage Collection with the 5.0 Java[tm] Virtual Machine

  java performance gc java5 sakaiaustin05 sakai

• 04 Apr 05
  

  Andrew M
• 17 Feb 05
  

  Edwin van Ouwerkerk Moria

  Java jvm specification programming

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.