src/hotspot/share/gc/shared/collectedHeap.hpp

rev 60513 : webrev12

*** 27,36 ****
--- 27,37 ----
  
  #include "gc/shared/gcCause.hpp"
  #include "gc/shared/gcWhen.hpp"
  #include "gc/shared/verifyOption.hpp"
  #include "memory/allocation.hpp"
+ #include "memory/heapInspection.hpp"
  #include "memory/universe.hpp"
  #include "runtime/handles.hpp"
  #include "runtime/perfData.hpp"
  #include "runtime/safepoint.hpp"
  #include "services/memoryUsage.hpp"
*** 42,51 ****
--- 43,53 ----
  // A "CollectedHeap" is an implementation of a java heap for HotSpot.  This
  // is an abstract class: there may be many different kinds of heaps.  This
  // class defines the functions that a heap must implement, and contains
  // infrastructure common to all heaps.
  
+ class AbstractGangTask;
  class AdaptiveSizePolicy;
  class BarrierSet;
  class GCHeapSummary;
  class GCTimer;
  class GCTracer;
*** 83,92 ****
--- 85,99 ----
    void log_heap_after(CollectedHeap* heap) {
      log_heap(heap, false);
    }
  };
  
+ class ParallelObjectIterator : public CHeapObj<mtGC> {
+ public:
+   virtual void object_iterate(ObjectClosure* cl, uint worker_id) = 0;
+ };
+ 
  //
  // CollectedHeap
  //   GenCollectedHeap
  //     SerialHeap
  //   G1CollectedHeap
*** 405,414 ****
--- 412,425 ----
    virtual GrowableArray<MemoryPool*> memory_pools() = 0;
  
    // Iterate over all objects, calling "cl.do_object" on each.
    virtual void object_iterate(ObjectClosure* cl) = 0;
  
+   virtual ParallelObjectIterator* parallel_object_iterator(uint thread_num) {
+     return NULL;
+   }
+ 
    // Keep alive an object that was loaded with AS_NO_KEEPALIVE.
    virtual void keep_alive(oop obj) {}
  
    // Perform any cleanup actions necessary before allowing a verification.
    virtual void prepare_for_verify() = 0;
*** 454,463 ****
--- 465,477 ----
    virtual bool print_location(outputStream* st, void* addr) const = 0;
  
    // Iterator for all GC threads (other than VM thread)
    virtual void gc_threads_do(ThreadClosure* tc) const = 0;
  
+   // Run given task. Possibly in parallel if the GC supports it.
+   virtual void run_task(AbstractGangTask* task) = 0;
+ 
    // Print any relevant tracing info that flags imply.
    // Default implementation does nothing.
    virtual void print_tracing_info() const = 0;
  
    void print_heap_before_gc();