jdk8-mips64-public/hotspot: comparison src/share/vm/memory/sharedHeap.hpp

-:882004b9e7e1
+:2c6ef90f030a
 //    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.
 // Example of using SubTasksDone and SequentialSubTasksDone
-// G1CollectedHeap::g1_process_strong_roots() calls
+// G1CollectedHeap::g1_process_roots()
-//  process_strong_roots(false, // no scoping; this is parallel code
+//  to SharedHeap::process_roots() and uses
-//                       is_scavenging, so,
-//                       &buf_scan_non_heap_roots,
-//                       &eager_scan_code_roots);
-//  which delegates to SharedHeap::process_strong_roots() and uses
 //  SubTasksDone* _process_strong_tasks to claim tasks.
-//  process_strong_roots() calls
+//  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
 // 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_strong_roots by sequential code, the parity is
+// 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_strong_roots" call only if its parity field is 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".
-private:
-void change_strong_roots_parity();
 public:
 int strong_roots_parity() { return _strong_roots_parity; }
-// Call these in sequential code around process_strong_roots.
+// 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 {
-public:
+// Used to implement the Thread work barrier.
-StrongRootsScope(SharedHeap* outer, bool activate = true);
+static Monitor* _lock;
+SharedHeap*   _sh;
+volatile jint _n_workers_done_with_threads;
+public:
+StrongRootsScope(SharedHeap* heap, bool activate = true);
 ~StrongRootsScope();
+// Mark that this thread is done with the Threads work.
+void mark_worker_done_with_threads(uint n_workers);
+// Wait until all n_workers are done with the Threads work.
+void wait_until_all_workers_done_with_threads(uint n_workers);
 };
 friend class StrongRootsScope;
+// The current active StrongRootScope
+StrongRootsScope* _strong_roots_scope;
+StrongRootsScope* active_strong_roots_scope() const;
+private:
+void register_strong_roots_scope(StrongRootsScope* scope);
+void unregister_strong_roots_scope(StrongRootsScope* scope);
+void change_strong_roots_parity();
+public:
 enum ScanningOption {
-SO_None                = 0x0,
+SO_None                =  0x0,
-SO_AllClasses          = 0x1,
+SO_AllCodeCache        =  0x8,
-SO_SystemClasses       = 0x2,
-SO_Strings             = 0x4,
-SO_AllCodeCache        = 0x8,
 SO_ScavengeCodeCache   = 0x10
 };
 FlexibleWorkGang* workers() const { return _workers; }
 // Invoke the "do_oop" method the closure "roots" on all root locations.
 // The "so" argument determines which roots the closure is applied to:
 // "SO_None" does none;
-// "SO_AllClasses" applies the closure to all entries in the SystemDictionary;
-// "SO_SystemClasses" to all the "system" classes and loaders;
-// "SO_Strings" applies the closure to all entries in StringTable;
 // "SO_AllCodeCache" applies the closure to all elements of the CodeCache.
 // "SO_ScavengeCodeCache" applies the closure to elements on the scavenge root list in the CodeCache.
+void process_roots(bool activate_scope,
+ScanningOption so,
+OopClosure* strong_roots,
+OopClosure* weak_roots,
+CLDClosure* strong_cld_closure,
+CLDClosure* weak_cld_closure,
+CodeBlobClosure* code_roots);
+void process_all_roots(bool activate_scope,
+ScanningOption so,
+OopClosure* roots,
+CLDClosure* cld_closure,
+CodeBlobClosure* code_roots);
 void process_strong_roots(bool activate_scope,
 ScanningOption so,
 OopClosure* roots,
-KlassClosure* klass_closure);
+CLDClosure* cld_closure,
+CodeBlobClosure* code_roots);
 // Apply "root_closure" to the JNI weak roots..
 void process_weak_roots(OopClosure* root_closure);
 // The functions below are helper functions that a subclass of
 // Do anything common to GC's.
 virtual void gc_prologue(bool full) = 0;
 virtual void gc_epilogue(bool full) = 0;
 // Sets the number of parallel threads that will be doing tasks
-// (such as process strong roots) subsequently.
+// (such as process roots) subsequently.
 virtual void set_par_threads(uint t);
 int n_termination();
 void set_n_termination(int t);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/sharedHeap.hpp

src/share/vm/memory/sharedHeap.hpp