*** old/src/share/vm/memory/collectorPolicy.hpp	Mon Sep 30 21:36:13 2013
--- new/src/share/vm/memory/collectorPolicy.hpp	Mon Sep 30 21:36:13 2013

*** 71,86 ****
--- 71,87 ----
    size_t _min_heap_byte_size;
  
    size_t _min_alignment;
    size_t _max_alignment;
  
!   // The sizing of the heap are controlled by a sizing policy.
!   // The sizing of the heap is controlled by a sizing policy.
    AdaptiveSizePolicy* _size_policy;
  
    // Set to true when policy wants soft refs cleared.
    // Reset to false by gc after it clears all soft refs.
    bool _should_clear_all_soft_refs;
+ 
    // Set to true by the GC if the just-completed gc cleared all
    // softrefs.  This is set to true whenever a gc clears all softrefs, and
    // set to false each time gc returns to the mutator.  For example, in the
    // ParallelScavengeHeap case the latter would be done toward the end of
    // mem_allocate() where it returns op.result()

*** 99,119 ****
--- 100,115 ----
  
   public:
    // Return maximum heap alignment that may be imposed by the policy
    static size_t compute_max_alignment();
  
    void set_min_alignment(size_t align)         { _min_alignment = align; }
    size_t min_alignment()                       { return _min_alignment; }
    void set_max_alignment(size_t align)         { _max_alignment = align; }
    size_t max_alignment()                       { return _max_alignment; }
  
    size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
    void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
    size_t max_heap_byte_size()     { return _max_heap_byte_size; }
    void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
    size_t min_heap_byte_size()     { return _min_heap_byte_size; }
    void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
  
    enum Name {
      CollectorPolicyKind,
      TwoGenerationCollectorPolicyKind,
      ConcurrentMarkSweepPolicyKind,

*** 180,190 ****
--- 176,186 ----
    // failure.
    virtual MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
                                                         size_t size,
                                                         Metaspace::MetadataType mdtype);
  
!   // Performace Counter support
!   // Performance Counter support
    GCPolicyCounters* counters()     { return _gc_policy_counters; }
  
    // Create the jstat counters for the GC policy.  By default, policy's
    // don't have associated counters, and we complain if this is invoked.
    virtual void initialize_gc_policy_counters() {

*** 235,245 ****
--- 231,241 ----
    void initialize_size_info();
  
    // Try to allocate space by expanding the heap.
    virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
  
-  // Scale the base_size by NewRation according to
   //     result = base_size / (NewRatio + 1)
   // and align by min_alignment()
   size_t scale_by_NewRatio_aligned(size_t base_size);
  
   // Bound the value by the given maximum minus the

*** 247,261 ****
--- 243,254 ----
   size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
  
   public:
    // Accessors
    size_t min_gen0_size() { return _min_gen0_size; }
    void set_min_gen0_size(size_t v) { _min_gen0_size = v; }
    size_t initial_gen0_size() { return _initial_gen0_size; }
    void set_initial_gen0_size(size_t v) { _initial_gen0_size = v; }
    size_t max_gen0_size() { return _max_gen0_size; }
    void set_max_gen0_size(size_t v) { _max_gen0_size = v; }
  
    virtual int number_of_generations() = 0;
  
    virtual GenerationSpec **generations()       {
      assert(_generations != NULL, "Sanity check");

*** 301,315 ****
--- 294,305 ----
    void initialize_generations()                { ShouldNotReachHere(); }
  
   public:
    // Accessors
    size_t min_gen1_size() { return _min_gen1_size; }
    void set_min_gen1_size(size_t v) { _min_gen1_size = v; }
    size_t initial_gen1_size() { return _initial_gen1_size; }
    void set_initial_gen1_size(size_t v) { _initial_gen1_size = v; }
    size_t max_gen1_size() { return _max_gen1_size; }
    void set_max_gen1_size(size_t v) { _max_gen1_size = v; }
  
    // Inherited methods
    TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
  
    int number_of_generations()                  { return 2; }