--- a/hotspot/src/share/vm/memory/sharedHeap.hpp	Thu Apr 02 16:06:07 2015 +0200
+++ b/hotspot/src/share/vm/memory/sharedHeap.hpp	Thu Apr 02 16:07:27 2015 +0200
@@ -27,62 +27,6 @@
 
 #include "gc_interface/collectedHeap.hpp"
 
-// A "SharedHeap" 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.
-
-// Note on use of FlexibleWorkGang's for GC.
-// There are three places where task completion is determined.
-// In
-//    1) ParallelTaskTerminator::offer_termination() where _n_threads
-//    must be set to the correct value so that count of workers that
-//    have offered termination will exactly match the number
-//    working on the task.  Tasks such as those derived from GCTask
-//    use ParallelTaskTerminator's.  Tasks that want load balancing
-//    by work stealing use this method to gauge completion.
-//    2) SubTasksDone has a variable _n_threads that is used in
-//    all_tasks_completed() to determine completion.  all_tasks_complete()
-//    counts the number of tasks that have been done and then reset
-//    the SubTasksDone so that it can be used again.  When the number of
-//    tasks is set to the number of GC workers, then _n_threads must
-//    be set to the number of active GC workers. G1RootProcessor and
-//    GenCollectedHeap have SubTasksDone.
-//    3) SequentialSubTasksDone has an _n_threads that is used in
-//    a way similar to SubTasksDone and has the same dependency on the
-//    number of active GC workers.  CompactibleFreeListSpace and Space
-//    have SequentialSubTasksDone's.
-//
-// Examples of using SubTasksDone and SequentialSubTasksDone:
-//  G1RootProcessor and GenCollectedHeap::process_roots() use
-//  SubTasksDone* _process_strong_tasks to claim tasks for workers
-//
-//  GenCollectedHeap::gen_process_roots() calls
-//      rem_set()->younger_refs_iterate()
-//  to scan the card table and which eventually calls down into
-//  CardTableModRefBS::par_non_clean_card_iterate_work().  This method
-//  uses SequentialSubTasksDone* _pst to claim tasks.
-//  Both SubTasksDone and SequentialSubTasksDone call their method
-//  all_tasks_completed() to count the number of GC workers that have
-//  finished their work.  That logic is "when all the workers are
-//  finished the tasks are finished".
-//
-//  The pattern that appears  in the code is to set _n_threads
-//  to a value > 1 before a task that you would like executed in parallel
-//  and then to set it to 0 after that task has completed.  A value of
-//  0 is a "special" value in set_n_threads() which translates to
-//  setting _n_threads to 1.
-//
-//  Some code uses _n_termination to decide if work should be done in
-//  parallel.  The notorious possibly_parallel_oops_do() in threads.cpp
-//  is an example of such code.  Look for variable "is_par" for other
-//  examples.
-//
-//  The active_workers is not reset to 0 after a parallel phase.  It's
-//  value may be used in later phases and in one instance at least
-//  (the parallel remark) it has to be used (the parallel remark depends
-//  on the partitioning done in the previous parallel scavenge).
-
 class SharedHeap : public CollectedHeap {
   friend class VMStructs;
 
@@ -90,48 +34,6 @@
   // Full initialization is done in a concrete subtype's "initialize"
   // function.
   SharedHeap();
-
-public:
-  // Note, the below comment needs to be updated to reflect the changes
-  // introduced by JDK-8076225. This should be done as part of JDK-8076289.
-  //
-  //Some collectors will perform "process_strong_roots" in parallel.
-  // Such a call will involve claiming some fine-grained tasks, such as
-  // scanning of threads.  To make this process simpler, we provide the
-  // "strong_roots_parity()" method.  Collectors that start parallel tasks
-  // whose threads invoke "process_strong_roots" must
-  // call "change_strong_roots_parity" in sequential code starting such a
-  // task.  (This also means that a parallel thread may only call
-  // process_strong_roots once.)
-  //
-  // For calls to process_roots by sequential code, the parity is
-  // updated automatically.
-  //
-  // The idea is that objects representing fine-grained tasks, such as
-  // threads, will contain a "parity" field.  A task will is claimed in the
-  // current "process_roots" call only if its parity field is the
-  // same as the "strong_roots_parity"; task claiming is accomplished by
-  // updating the parity field to the strong_roots_parity with a CAS.
-  //
-  // If the client meats this spec, then strong_roots_parity() will have
-  // the following properties:
-  //   a) to return a different value than was returned before the last
-  //      call to change_strong_roots_parity, and
-  //   c) to never return a distinguished value (zero) with which such
-  //      task-claiming variables may be initialized, to indicate "never
-  //      claimed".
- public:
-
-  // Call these in sequential code around process_roots.
-  // strong_roots_prologue calls change_strong_roots_parity, if
-  // parallel tasks are enabled.
-  class StrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
-    SharedHeap*   _sh;
-
-   public:
-    StrongRootsScope(SharedHeap* heap, bool activate = true);
-    ~StrongRootsScope();
-  };
  };
 
 #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP