src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp

*** 23,46 ****
   */
  
  #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  
  #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
  #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
  #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
  #include "gc_implementation/shared/gcPolicyCounters.hpp"
  #include "gc_implementation/shared/gcWhen.hpp"
  #include "gc_interface/collectedHeap.inline.hpp"
  #include "utilities/ostream.hpp"
  
  class AdjoiningGenerations;
  class GCHeapSummary;
  class GCTaskManager;
- class GenerationSizer;
- class CollectorPolicy;
  class PSAdaptiveSizePolicy;
  class PSHeapSummary;
  
  class ParallelScavengeHeap : public CollectedHeap {
    friend class VMStructs;
--- 23,46 ----
   */
  
  #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  
+ #include "gc_implementation/parallelScavenge/generationSizer.hpp"
  #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
  #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
  #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
  #include "gc_implementation/shared/gcPolicyCounters.hpp"
  #include "gc_implementation/shared/gcWhen.hpp"
  #include "gc_interface/collectedHeap.inline.hpp"
+ #include "memory/collectorPolicy.hpp"
  #include "utilities/ostream.hpp"
  
  class AdjoiningGenerations;
  class GCHeapSummary;
  class GCTaskManager;
  class PSAdaptiveSizePolicy;
  class PSHeapSummary;
  
  class ParallelScavengeHeap : public CollectedHeap {
    friend class VMStructs;
*** 52,68 ****
    static PSAdaptiveSizePolicy*       _size_policy;
    static PSGCAdaptivePolicyCounters* _gc_policy_counters;
  
    static ParallelScavengeHeap* _psh;
  
-   size_t _young_gen_alignment;
-   size_t _old_gen_alignment;
- 
    GenerationSizer* _collector_policy;
  
-   inline size_t set_alignment(size_t& var, size_t val);
- 
    // Collection of generations that are adjacent in the
    // space reserved for the heap.
    AdjoiningGenerations* _gens;
    unsigned int _death_march_count;
  
--- 52,63 ----
*** 78,96 ****
    inline bool should_alloc_in_eden(size_t size) const;
    inline void death_march_check(HeapWord* const result, size_t size);
    HeapWord* mem_allocate_old_gen(size_t size);
  
   public:
!   ParallelScavengeHeap() : CollectedHeap(), _death_march_count(0) {
!     set_alignment(_young_gen_alignment, intra_heap_alignment());
!     set_alignment(_old_gen_alignment, intra_heap_alignment());
!   }
! 
!   // Return the (conservative) maximum heap alignment
!   static size_t conservative_max_heap_alignment() {
!     return GenCollectorPolicy::intra_heap_alignment();
!   }
  
    // For use by VM operations
    enum CollectionType {
      Scavenge,
      MarkSweep
--- 73,83 ----
    inline bool should_alloc_in_eden(size_t size) const;
    inline void death_march_check(HeapWord* const result, size_t size);
    HeapWord* mem_allocate_old_gen(size_t size);
  
   public:
!   ParallelScavengeHeap() : CollectedHeap(), _death_march_count(0) { }
  
    // For use by VM operations
    enum CollectionType {
      Scavenge,
      MarkSweep
*** 118,134 ****
    // Returns JNI_OK on success
    virtual jint initialize();
  
    void post_initialize();
    void update_counters();
!   // The alignment used for the various generations.
!   size_t young_gen_alignment() const { return _young_gen_alignment; }
!   size_t old_gen_alignment()  const { return _old_gen_alignment; }
! 
!   // The alignment used for eden and survivors within the young gen
!   // and for boundary between young gen and old gen.
!   size_t intra_heap_alignment() { return GenCollectorPolicy::intra_heap_alignment(); }
  
    size_t capacity() const;
    size_t used() const;
  
    // Return "true" if all generations have reached the
--- 105,123 ----
    // Returns JNI_OK on success
    virtual jint initialize();
  
    void post_initialize();
    void update_counters();
! 
!   // The alignment used for the various areas
!   size_t space_alignment()      { return _collector_policy->space_alignment(); }
!   size_t generation_alignment() { return _collector_policy->gen_alignment(); }
! 
!   // Return the (conservative) maximum heap alignment
!   static size_t conservative_max_heap_alignment() {
!     return CollectorPolicy::compute_heap_alignment();
!   }
  
    size_t capacity() const;
    size_t used() const;
  
    // Return "true" if all generations have reached the
*** 259,271 ****
      ParStrongRootsScope();
      ~ParStrongRootsScope();
    };
  };
  
- inline size_t ParallelScavengeHeap::set_alignment(size_t& var, size_t val)
- {
-   assert(is_power_of_2((intptr_t)val), "must be a power of 2");
-   var = round_to(val, intra_heap_alignment());
-   return var;
- }
- 
  #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
--- 248,253 ----