< prev index next >

src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp

Print this page
rev 47972 : [mq]: open.patch
   1 /*
   2  * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  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_PARALLEL_PARALLELSCAVENGEHEAP_HPP
  26 #define SHARE_VM_GC_PARALLEL_PARALLELSCAVENGEHEAP_HPP
  27 
  28 #include "gc/parallel/generationSizer.hpp"
  29 #include "gc/parallel/objectStartArray.hpp"
  30 #include "gc/parallel/psGCAdaptivePolicyCounters.hpp"
  31 #include "gc/parallel/psOldGen.hpp"
  32 #include "gc/parallel/psYoungGen.hpp"
  33 #include "gc/shared/collectedHeap.hpp"
  34 #include "gc/shared/collectorPolicy.hpp"
  35 #include "gc/shared/gcPolicyCounters.hpp"
  36 #include "gc/shared/gcWhen.hpp"
  37 #include "gc/shared/strongRootsScope.hpp"
  38 #include "memory/metaspace.hpp"

  39 #include "utilities/ostream.hpp"
  40 
  41 class AdjoiningGenerations;
  42 class GCHeapSummary;
  43 class GCTaskManager;


  44 class PSAdaptiveSizePolicy;
  45 class PSHeapSummary;
  46 
  47 class ParallelScavengeHeap : public CollectedHeap {
  48   friend class VMStructs;
  49  private:
  50   static PSYoungGen* _young_gen;
  51   static PSOldGen*   _old_gen;
  52 
  53   // Sizing policy for entire heap
  54   static PSAdaptiveSizePolicy*       _size_policy;
  55   static PSGCAdaptivePolicyCounters* _gc_policy_counters;
  56 
  57   GenerationSizer* _collector_policy;
  58 
  59   // Collection of generations that are adjacent in the
  60   // space reserved for the heap.
  61   AdjoiningGenerations* _gens;
  62   unsigned int _death_march_count;
  63 
  64   // The task manager
  65   static GCTaskManager* _gc_task_manager;
  66 







  67   void trace_heap(GCWhen::Type when, const GCTracer* tracer);
  68 
  69  protected:
  70   static inline size_t total_invocations();
  71   HeapWord* allocate_new_tlab(size_t size);
  72 
  73   inline bool should_alloc_in_eden(size_t size) const;
  74   inline void death_march_check(HeapWord* const result, size_t size);
  75   HeapWord* mem_allocate_old_gen(size_t size);
  76 
  77  public:
  78   ParallelScavengeHeap(GenerationSizer* policy) :
  79     CollectedHeap(), _collector_policy(policy), _death_march_count(0) { }
  80 
  81   // For use by VM operations
  82   enum CollectionType {
  83     Scavenge,
  84     MarkSweep
  85   };
  86 
  87   virtual Name kind() const {
  88     return CollectedHeap::ParallelScavengeHeap;
  89   }
  90 
  91   virtual const char* name() const {
  92     return "Parallel";
  93   }
  94 
  95   virtual CollectorPolicy* collector_policy() const { return _collector_policy; }
  96 



  97   static PSYoungGen* young_gen() { return _young_gen; }
  98   static PSOldGen* old_gen()     { return _old_gen; }
  99 
 100   virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; }
 101 
 102   static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
 103 
 104   static ParallelScavengeHeap* heap();
 105 
 106   static GCTaskManager* const gc_task_manager() { return _gc_task_manager; }
 107 
 108   AdjoiningGenerations* gens() { return _gens; }
 109 
 110   // Returns JNI_OK on success
 111   virtual jint initialize();
 112 
 113   void post_initialize();
 114   void update_counters();
 115 
 116   // The alignment used for the various areas


 227   // Resize the young generation.  The reserved space for the
 228   // generation may be expanded in preparation for the resize.
 229   void resize_young_gen(size_t eden_size, size_t survivor_size);
 230 
 231   // Resize the old generation.  The reserved space for the
 232   // generation may be expanded in preparation for the resize.
 233   void resize_old_gen(size_t desired_free_space);
 234 
 235   // Save the tops of the spaces in all generations
 236   void record_gen_tops_before_GC() PRODUCT_RETURN;
 237 
 238   // Mangle the unused parts of all spaces in the heap
 239   void gen_mangle_unused_area() PRODUCT_RETURN;
 240 
 241   // Call these in sequential code around the processing of strong roots.
 242   class ParStrongRootsScope : public MarkScope {
 243    public:
 244     ParStrongRootsScope();
 245     ~ParStrongRootsScope();
 246   };



 247 };
 248 
 249 // Simple class for storing info about the heap at the start of GC, to be used
 250 // after GC for comparison/printing.
 251 class PreGCValues {
 252 public:
 253   PreGCValues(ParallelScavengeHeap* heap) :
 254       _heap_used(heap->used()),
 255       _young_gen_used(heap->young_gen()->used_in_bytes()),
 256       _old_gen_used(heap->old_gen()->used_in_bytes()),
 257       _metadata_used(MetaspaceAux::used_bytes()) { };
 258 
 259   size_t heap_used() const      { return _heap_used; }
 260   size_t young_gen_used() const { return _young_gen_used; }
 261   size_t old_gen_used() const   { return _old_gen_used; }
 262   size_t metadata_used() const  { return _metadata_used; }
 263 
 264 private:
 265   size_t _heap_used;
 266   size_t _young_gen_used;


   1 /*
   2  * Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  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_PARALLEL_PARALLELSCAVENGEHEAP_HPP
  26 #define SHARE_VM_GC_PARALLEL_PARALLELSCAVENGEHEAP_HPP
  27 
  28 #include "gc/parallel/generationSizer.hpp"
  29 #include "gc/parallel/objectStartArray.hpp"
  30 #include "gc/parallel/psGCAdaptivePolicyCounters.hpp"
  31 #include "gc/parallel/psOldGen.hpp"
  32 #include "gc/parallel/psYoungGen.hpp"
  33 #include "gc/shared/collectedHeap.hpp"
  34 #include "gc/shared/collectorPolicy.hpp"
  35 #include "gc/shared/gcPolicyCounters.hpp"
  36 #include "gc/shared/gcWhen.hpp"
  37 #include "gc/shared/strongRootsScope.hpp"
  38 #include "memory/metaspace.hpp"
  39 #include "utilities/growableArray.hpp"
  40 #include "utilities/ostream.hpp"
  41 
  42 class AdjoiningGenerations;
  43 class GCHeapSummary;
  44 class GCTaskManager;
  45 class MemoryManager;
  46 class MemoryPool;
  47 class PSAdaptiveSizePolicy;
  48 class PSHeapSummary;
  49 
  50 class ParallelScavengeHeap : public CollectedHeap {
  51   friend class VMStructs;
  52  private:
  53   static PSYoungGen* _young_gen;
  54   static PSOldGen*   _old_gen;
  55 
  56   // Sizing policy for entire heap
  57   static PSAdaptiveSizePolicy*       _size_policy;
  58   static PSGCAdaptivePolicyCounters* _gc_policy_counters;
  59 
  60   GenerationSizer* _collector_policy;
  61 
  62   // Collection of generations that are adjacent in the
  63   // space reserved for the heap.
  64   AdjoiningGenerations* _gens;
  65   unsigned int _death_march_count;
  66 
  67   // The task manager
  68   static GCTaskManager* _gc_task_manager;
  69 
  70   GCMemoryManager* _young_mgr;
  71   GCMemoryManager* _old_mgr;
  72 
  73   MemoryPool* _eden_pool;
  74   MemoryPool* _survivor_pool;
  75   MemoryPool* _old_pool;
  76 
  77   void trace_heap(GCWhen::Type when, const GCTracer* tracer);
  78 
  79  protected:
  80   static inline size_t total_invocations();
  81   HeapWord* allocate_new_tlab(size_t size);
  82 
  83   inline bool should_alloc_in_eden(size_t size) const;
  84   inline void death_march_check(HeapWord* const result, size_t size);
  85   HeapWord* mem_allocate_old_gen(size_t size);
  86 
  87  public:
  88   ParallelScavengeHeap(GenerationSizer* policy) :
  89     CollectedHeap(), _collector_policy(policy), _death_march_count(0) { }
  90 
  91   // For use by VM operations
  92   enum CollectionType {
  93     Scavenge,
  94     MarkSweep
  95   };
  96 
  97   virtual Name kind() const {
  98     return CollectedHeap::ParallelScavengeHeap;
  99   }
 100 
 101   virtual const char* name() const {
 102     return "Parallel";
 103   }
 104 
 105   virtual CollectorPolicy* collector_policy() const { return _collector_policy; }
 106 
 107   virtual GrowableArray<GCMemoryManager*> memory_managers();
 108   virtual GrowableArray<MemoryPool*> memory_pools();
 109 
 110   static PSYoungGen* young_gen() { return _young_gen; }
 111   static PSOldGen* old_gen()     { return _old_gen; }
 112 
 113   virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; }
 114 
 115   static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
 116 
 117   static ParallelScavengeHeap* heap();
 118 
 119   static GCTaskManager* const gc_task_manager() { return _gc_task_manager; }
 120 
 121   AdjoiningGenerations* gens() { return _gens; }
 122 
 123   // Returns JNI_OK on success
 124   virtual jint initialize();
 125 
 126   void post_initialize();
 127   void update_counters();
 128 
 129   // The alignment used for the various areas


 240   // Resize the young generation.  The reserved space for the
 241   // generation may be expanded in preparation for the resize.
 242   void resize_young_gen(size_t eden_size, size_t survivor_size);
 243 
 244   // Resize the old generation.  The reserved space for the
 245   // generation may be expanded in preparation for the resize.
 246   void resize_old_gen(size_t desired_free_space);
 247 
 248   // Save the tops of the spaces in all generations
 249   void record_gen_tops_before_GC() PRODUCT_RETURN;
 250 
 251   // Mangle the unused parts of all spaces in the heap
 252   void gen_mangle_unused_area() PRODUCT_RETURN;
 253 
 254   // Call these in sequential code around the processing of strong roots.
 255   class ParStrongRootsScope : public MarkScope {
 256    public:
 257     ParStrongRootsScope();
 258     ~ParStrongRootsScope();
 259   };
 260 
 261   GCMemoryManager* old_gc_mgr() const { return _old_mgr; }
 262   GCMemoryManager* young_gc_mgr() const { return _young_mgr; }
 263 };
 264 
 265 // Simple class for storing info about the heap at the start of GC, to be used
 266 // after GC for comparison/printing.
 267 class PreGCValues {
 268 public:
 269   PreGCValues(ParallelScavengeHeap* heap) :
 270       _heap_used(heap->used()),
 271       _young_gen_used(heap->young_gen()->used_in_bytes()),
 272       _old_gen_used(heap->old_gen()->used_in_bytes()),
 273       _metadata_used(MetaspaceAux::used_bytes()) { };
 274 
 275   size_t heap_used() const      { return _heap_used; }
 276   size_t young_gen_used() const { return _young_gen_used; }
 277   size_t old_gen_used() const   { return _old_gen_used; }
 278   size_t metadata_used() const  { return _metadata_used; }
 279 
 280 private:
 281   size_t _heap_used;
 282   size_t _young_gen_used;


< prev index next >