< prev index next >

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

Print this page

        

@@ -31,22 +31,21 @@
 #include "gc/parallel/psYoungGen.hpp"
 #include "gc/shared/cardTableBarrierSet.hpp"
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/gcPolicyCounters.hpp"
 #include "gc/shared/gcWhen.hpp"
-#include "gc/shared/preGCValues.hpp"
 #include "gc/shared/referenceProcessor.hpp"
 #include "gc/shared/softRefPolicy.hpp"
 #include "gc/shared/strongRootsScope.hpp"
-#include "gc/shared/workgroup.hpp"
 #include "logging/log.hpp"
 #include "memory/metaspace.hpp"
 #include "utilities/growableArray.hpp"
 #include "utilities/ostream.hpp"
 
 class AdjoiningGenerations;
 class GCHeapSummary;
+class GCTaskManager;
 class MemoryManager;
 class MemoryPool;
 class PSAdaptiveSizePolicy;
 class PSCardTable;
 class PSHeapSummary;

@@ -66,19 +65,20 @@
   // Collection of generations that are adjacent in the
   // space reserved for the heap.
   AdjoiningGenerations* _gens;
   unsigned int _death_march_count;
 
+  // The task manager
+  static GCTaskManager* _gc_task_manager;
+
   GCMemoryManager* _young_manager;
   GCMemoryManager* _old_manager;
 
   MemoryPool* _eden_pool;
   MemoryPool* _survivor_pool;
   MemoryPool* _old_pool;
 
-  WorkGang _workers;
-
   virtual void initialize_serviceability();
 
   void trace_heap(GCWhen::Type when, const GCTracer* tracer);
 
  protected:

@@ -96,15 +96,11 @@
     _death_march_count(0),
     _young_manager(NULL),
     _old_manager(NULL),
     _eden_pool(NULL),
     _survivor_pool(NULL),
-    _old_pool(NULL),
-    _workers("GC Thread",
-             ParallelGCThreads,
-             true /* are_GC_task_threads */,
-             false /* are_ConcurrentGC_threads */) { }
+    _old_pool(NULL) { }
 
   // For use by VM operations
   enum CollectionType {
     Scavenge,
     MarkSweep

@@ -130,10 +126,12 @@
 
   static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
 
   static ParallelScavengeHeap* heap();
 
+  static GCTaskManager* const gc_task_manager() { return _gc_task_manager; }
+
   CardTableBarrierSet* barrier_set();
   PSCardTable* card_table();
 
   AdjoiningGenerations* gens() { return _gens; }
 

@@ -166,13 +164,10 @@
   bool is_in_reserved(const void* p) const;
 
   bool is_in_young(oop p);  // reserved part
   bool is_in_old(oop p);    // reserved part
 
-  MemRegion reserved_region() const { return _reserved; }
-  HeapWord* base() const { return _reserved.start(); }
-
   // Memory allocation.   "gc_time_limit_was_exceeded" will
   // be set to true if the adaptive size policy determine that
   // an excessive amount of time is being spent doing collections
   // and caused a NULL to be returned.  If a NULL is not returned,
   // "gc_time_limit_was_exceeded" has an undefined meaning.

@@ -226,16 +221,10 @@
   virtual void print_on_error(outputStream* st) const;
   virtual void print_gc_threads_on(outputStream* st) const;
   virtual void gc_threads_do(ThreadClosure* tc) const;
   virtual void print_tracing_info() const;
 
-  PreGenGCValues get_pre_gc_values() const;
-  void print_heap_change(const PreGenGCValues& pre_gc_values) const;
-
-  // Used to print information about locations in the hs_err file.
-  virtual bool print_location(outputStream* st, void* addr) const;
-
   void verify(VerifyOption option /* ignored */);
 
   // Resize the young generation.  The reserved space for the
   // generation may be expanded in preparation for the resize.
   void resize_young_gen(size_t eden_size, size_t survivor_size);

@@ -257,14 +246,32 @@
     ~ParStrongRootsScope();
   };
 
   GCMemoryManager* old_gc_manager() const { return _old_manager; }
   GCMemoryManager* young_gc_manager() const { return _young_manager; }
+};
 
-  WorkGang& workers() {
-    return _workers;
-  }
+// Simple class for storing info about the heap at the start of GC, to be used
+// after GC for comparison/printing.
+class PreGCValues {
+public:
+  PreGCValues(ParallelScavengeHeap* heap) :
+      _heap_used(heap->used()),
+      _young_gen_used(heap->young_gen()->used_in_bytes()),
+      _old_gen_used(heap->old_gen()->used_in_bytes()),
+      _metadata_used(MetaspaceUtils::used_bytes()) { };
+
+  size_t heap_used() const      { return _heap_used; }
+  size_t young_gen_used() const { return _young_gen_used; }
+  size_t old_gen_used() const   { return _old_gen_used; }
+  size_t metadata_used() const  { return _metadata_used; }
+
+private:
+  size_t _heap_used;
+  size_t _young_gen_used;
+  size_t _old_gen_used;
+  size_t _metadata_used;
 };
 
 // Class that can be used to print information about the
 // adaptive size policy at intervals specified by
 // AdaptiveSizePolicyOutputInterval.  Only print information
< prev index next >