17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  27 
  28 #include "gc_implementation/parallelScavenge/generationSizer.hpp"
  29 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
  30 #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
  31 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  32 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
  33 #include "gc_implementation/shared/gcPolicyCounters.hpp"
  34 #include "gc_implementation/shared/gcWhen.hpp"
  35 #include "gc_interface/collectedHeap.inline.hpp"
  36 #include "memory/collectorPolicy.hpp"

  37 #include "utilities/ostream.hpp"
  38 
  39 class AdjoiningGenerations;
  40 class GCHeapSummary;
  41 class GCTaskManager;
  42 class PSAdaptiveSizePolicy;
  43 class PSHeapSummary;
  44 
  45 class ParallelScavengeHeap : public CollectedHeap {
  46   friend class VMStructs;
  47  private:
  48   static PSYoungGen* _young_gen;
  49   static PSOldGen*   _old_gen;
  50 
  51   // Sizing policy for entire heap
  52   static PSAdaptiveSizePolicy*       _size_policy;
  53   static PSGCAdaptivePolicyCounters* _gc_policy_counters;
  54 
  55   static ParallelScavengeHeap* _psh;
  56 

 220 
 221   void verify(bool silent, VerifyOption option /* ignored */);
 222 
 223   void print_heap_change(size_t prev_used);
 224 
 225   // Resize the young generation.  The reserved space for the
 226   // generation may be expanded in preparation for the resize.
 227   void resize_young_gen(size_t eden_size, size_t survivor_size);
 228 
 229   // Resize the old generation.  The reserved space for the
 230   // generation may be expanded in preparation for the resize.
 231   void resize_old_gen(size_t desired_free_space);
 232 
 233   // Save the tops of the spaces in all generations
 234   void record_gen_tops_before_GC() PRODUCT_RETURN;
 235 
 236   // Mangle the unused parts of all spaces in the heap
 237   void gen_mangle_unused_area() PRODUCT_RETURN;
 238 
 239   // Call these in sequential code around the processing of strong roots.
 240   class ParStrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
 241    public:
 242     ParStrongRootsScope();
 243     ~ParStrongRootsScope();
 244   };
 245 };
 246 
 247 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP

  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
  27 
  28 #include "gc_implementation/parallelScavenge/generationSizer.hpp"
  29 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
  30 #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
  31 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  32 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
  33 #include "gc_implementation/shared/gcPolicyCounters.hpp"
  34 #include "gc_implementation/shared/gcWhen.hpp"
  35 #include "gc_interface/collectedHeap.inline.hpp"
  36 #include "memory/collectorPolicy.hpp"
  37 #include "memory/strongRootsScope.hpp"
  38 #include "utilities/ostream.hpp"
  39 
  40 class AdjoiningGenerations;
  41 class GCHeapSummary;
  42 class GCTaskManager;
  43 class PSAdaptiveSizePolicy;
  44 class PSHeapSummary;
  45 
  46 class ParallelScavengeHeap : public CollectedHeap {
  47   friend class VMStructs;
  48  private:
  49   static PSYoungGen* _young_gen;
  50   static PSOldGen*   _old_gen;
  51 
  52   // Sizing policy for entire heap
  53   static PSAdaptiveSizePolicy*       _size_policy;
  54   static PSGCAdaptivePolicyCounters* _gc_policy_counters;
  55 
  56   static ParallelScavengeHeap* _psh;
  57 

 221 
 222   void verify(bool silent, VerifyOption option /* ignored */);
 223 
 224   void print_heap_change(size_t prev_used);
 225 
 226   // Resize the young generation.  The reserved space for the
 227   // generation may be expanded in preparation for the resize.
 228   void resize_young_gen(size_t eden_size, size_t survivor_size);
 229 
 230   // Resize the old generation.  The reserved space for the
 231   // generation may be expanded in preparation for the resize.
 232   void resize_old_gen(size_t desired_free_space);
 233 
 234   // Save the tops of the spaces in all generations
 235   void record_gen_tops_before_GC() PRODUCT_RETURN;
 236 
 237   // Mangle the unused parts of all spaces in the heap
 238   void gen_mangle_unused_area() PRODUCT_RETURN;
 239 
 240   // Call these in sequential code around the processing of strong roots.
 241   class ParStrongRootsScope : public MarkScope {
 242    public:
 243     ParStrongRootsScope();
 244     ~ParStrongRootsScope();
 245   };
 246 };
 247 
 248 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP