graal-jvmci-8: src/share/vm/memory/sharedHeap.hpp comparison

comparison src/share/vm/memory/sharedHeap.hpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	89152779163c 2c6ef90f030a
children	dd9cc155639c

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 //    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
 GenRemSet* rem_set() { return _rem_set; }
 // Iteration functions.
 void oop_iterate(ExtendedOopClosure* cl) = 0;
-// Same as above, restricted to a memory region.
-virtual void oop_iterate(MemRegion mr, ExtendedOopClosure* cl) = 0;
 // Iterate over all spaces in use in the heap, in an undefined order.
 virtual void space_iterate(SpaceClosure* cl) = 0;
 // A SharedHeap will contain some number of spaces.  This finds the
 // space whose reserved area contains the given address, or else returns
 // 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_ScavengeCodeCache   = 0x10
-SO_Strings             = 0x4,
-SO_CodeCache           = 0x8
 };
 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_AllCodeCache" applies the closure to all elements of the CodeCache.
-// "SO_SystemClasses" to all the "system" classes and loaders;
+// "SO_ScavengeCodeCache" applies the closure to elements on the scavenge root list in the CodeCache.
-// "SO_Strings" applies the closure to all entries in StringTable;
+void process_roots(bool activate_scope,
-// "SO_CodeCache" applies the closure to all elements of the CodeCache.
+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,
-bool is_scavenging,
 ScanningOption so,
 OopClosure* roots,
-CodeBlobClosure* code_roots,
+CLDClosure* cld_closure,
-KlassClosure* klass_closure);
+CodeBlobClosure* code_roots);
-// Apply "blk" to all the weak roots of the system.  These include
-// JNI weak roots, the code cache, system dictionary, symbol table,
+// Apply "root_closure" to the JNI weak roots..
-// string table.
+void process_weak_roots(OopClosure* root_closure);
-void process_weak_roots(OopClosure* root_closure,
-CodeBlobClosure* code_roots);
 // The functions below are helper functions that a subclass of
 // "SharedHeap" can use in the implementation of its virtual
 // functions.
 // 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);
 size_t bytes_before,
 size_t bytes_after,
 size_t capacity);
 };
+inline SharedHeap::ScanningOption operator|(SharedHeap::ScanningOption so0, SharedHeap::ScanningOption so1) {
+return static_cast<SharedHeap::ScanningOption>(static_cast<int>(so0) | static_cast<int>(so1));
+}
 #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/sharedHeap.hpp @ 20804:7848fc12602b