truffle: src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	2e6857353b2c
children	ad747ee9d0b1 9412b1915547

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 // may combine concurrent marking with parallel, incremental compaction of
 // heap subsets that will yield large amounts of garbage.
 class HeapRegion;
 class HRRSCleanupTask;
-class PermanentGenerationSpec;
 class GenerationSpec;
 class OopsInHeapRegionClosure;
+class G1KlassScanClosure;
 class G1ScanHeapEvacClosure;
 class ObjectClosure;
 class SpaceClosure;
 class CompactibleSpaceClosure;
 class Space;
 class RefineCardTableEntryClosure;
 class G1CollectedHeap : public SharedHeap {
 friend class VM_G1CollectForAllocation;
-friend class VM_GenCollectForPermanentAllocation;
 friend class VM_G1CollectFull;
 friend class VM_G1IncCollectionPause;
 friend class VMStructs;
 friend class MutatorAllocRegion;
 friend class SurvivorGCAllocRegion;
 // The one and only G1CollectedHeap, so static functions can find it.
 static G1CollectedHeap* _g1h;
 static size_t _humongous_object_threshold_in_words;
-// Storage for the G1 heap (excludes the permanent generation).
+// Storage for the G1 heap.
 VirtualSpace _g1_storage;
 MemRegion    _g1_reserved;
 // The part of _g1_storage that is currently committed.
 MemRegion _g1_committed;
 // It initializes the GC alloc regions at the start of a GC.
 void init_gc_alloc_regions();
 // It releases the GC alloc regions at the end of a GC.
-void release_gc_alloc_regions();
+void release_gc_alloc_regions(uint no_of_gc_workers);
 // It does any cleanup that needs to be done on the GC alloc regions
 // before a Full GC.
 void abandon_gc_alloc_regions();
 void print_hrs_post_compaction();
 double verify(bool guard, const char* msg);
 void verify_before_gc();
 void verify_after_gc();
+void log_gc_header();
+void log_gc_footer(double pause_time_sec);
 // These are macros so that, if the assert fires, we get the correct
 // line number, file, etc.
 #define heap_locking_asserts_err_msg(_extra_message_)                         \
 bool clear_all_soft_refs,
 size_t word_size);
 // Callback from VM_G1CollectFull operation.
 // Perform a full collection.
-void do_full_collection(bool clear_all_soft_refs);
+virtual void do_full_collection(bool clear_all_soft_refs);
 // Resize the heap if necessary after a full collection.  If this is
 // after a collect-for allocation, "word_size" is the allocation size,
 // and will be considered part of the used portion of the heap.
 void resize_if_necessary_after_full_collection(size_t word_size);
 // allocated block, or else "NULL".
 HeapWord* expand_and_allocate(size_t word_size);
 // Process any reference objects discovered during
 // an incremental evacuation pause.
-void process_discovered_references();
+void process_discovered_references(uint no_of_gc_workers);
 // Enqueue any remaining discovered references
 // after processing.
-void enqueue_discovered_references();
+void enqueue_discovered_references(uint no_of_gc_workers);
 public:
 G1MonitoringSupport* g1mm() {
 assert(_g1mm != NULL, "should have been initialized");
 // statistics or updating free lists.
 void abandon_collection_set(HeapRegion* cs_head);
 // Applies "scan_non_heap_roots" to roots outside the heap,
 // "scan_rs" to roots inside the heap (having done "set_region" to
-// indicate the region in which the root resides), and does "scan_perm"
+// indicate the region in which the root resides),
-// (setting the generation to the perm generation.)  If "scan_rs" is
+// and does "scan_metadata" If "scan_rs" is
 // NULL, then this step is skipped.  The "worker_i"
 // param is for use with parallel roots processing, and should be
 // the "i" of the calling parallel worker thread's work(i) function.
 // In the sequential case this param will be ignored.
-void g1_process_strong_roots(bool collecting_perm_gen,
+void g1_process_strong_roots(bool is_scavenging,
 ScanningOption so,
 OopClosure* scan_non_heap_roots,
 OopsInHeapRegionClosure* scan_rs,
-OopsInGenClosure* scan_perm,
+G1KlassScanClosure* scan_klasses,
 int worker_i);
 // Apply "blk" to all the weak roots of the system.  These include
 // JNI weak roots, the code cache, system dictionary, symbol table,
 // string table, and referents of reachable weak refs.
 // Must call the initialize method afterwards.
 // May not return if something goes wrong.
 G1CollectedHeap(G1CollectorPolicy* policy);
 // Initialize the G1CollectedHeap to have the initial and
-// maximum sizes, permanent generation, and remembered and barrier sets
+// maximum sizes and remembered and barrier sets
 // specified by the policy object.
 jint initialize();
 // Initialize weak reference processing.
 virtual void ref_processing_init();
 return CollectedHeap::G1CollectedHeap;
 }
 // The current policy object for the collector.
 G1CollectorPolicy* g1_policy() const { return _g1_policy; }
+virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) g1_policy(); }
 // Adaptive size policy.  No such thing for g1.
 virtual AdaptiveSizePolicy* size_policy() { return NULL; }
 // The rem set and barrier set.
 // "CollectedHeap" supports.
 virtual void collect(GCCause::Cause cause);
 // The same as above but assume that the caller holds the Heap_lock.
 void collect_locked(GCCause::Cause cause);
-// This interface assumes that it's being called by the
-// vm thread. It collects the heap assuming that the
-// heap lock is already held and that we are executing in
-// the context of the vm thread.
-virtual void collect_as_vm_thread(GCCause::Cause cause);
 // True iff a evacuation has failed in the most-recent collection.
 bool evacuation_failed() { return _evacuation_failed; }
 // It will free a region if it has allocated objects in it that are
 // Return "TRUE" iff the given object address is within the collection
 // set.
 inline bool obj_in_cs(oop obj);
 // Return "TRUE" iff the given object address is in the reserved
-// region of g1 (excluding the permanent generation).
+// region of g1.
 bool is_in_g1_reserved(const void* p) const {
 return _g1_reserved.contains(p);
 }
 // Returns a MemRegion that corresponds to the space that has been
 // Iteration functions.
 // Iterate over all the ref-containing fields of all objects, calling
 // "cl.do_oop" on each.
-virtual void oop_iterate(OopClosure* cl) {
+virtual void oop_iterate(ExtendedOopClosure* cl);
-oop_iterate(cl, true);
-}
-void oop_iterate(OopClosure* cl, bool do_perm);
 // Same as above, restricted to a memory region.
-virtual void oop_iterate(MemRegion mr, OopClosure* cl) {
+void oop_iterate(MemRegion mr, ExtendedOopClosure* cl);
-oop_iterate(mr, cl, true);
-}
-void oop_iterate(MemRegion mr, OopClosure* cl, bool do_perm);
 // Iterate over all objects, calling "cl.do_object" on each.
-virtual void object_iterate(ObjectClosure* cl) {
+virtual void object_iterate(ObjectClosure* cl);
-object_iterate(cl, true);
-}
 virtual void safe_object_iterate(ObjectClosure* cl) {
-object_iterate(cl, true);
+object_iterate(cl);
 }
-void object_iterate(ObjectClosure* cl, bool do_perm);
 // Iterate over all objects allocated since the last collection, calling
 // "cl.do_object" on each.  The heap must have been initialized properly
 // to support this function, or else this call will fail.
 virtual void object_iterate_since_last_GC(ObjectClosure* cl);
 // information for young gen objects.
 virtual bool can_elide_initializing_store_barrier(oop new_obj) {
 return is_in_young(new_obj);
 }
-// Can a compiler elide a store barrier when it writes
-// a permanent oop into the heap?  Applies when the compiler
-// is storing x to the heap, where x->is_perm() is true.
-virtual bool can_elide_permanent_oop_store_barriers() const {
-// At least until perm gen collection is also G1-ified, at
-// which point this should return false.
-return true;
-}
 // Returns "true" iff the given word_size is "very large".
 static bool isHumongous(size_t word_size) {
 // Note this has to be strictly greater-than as the TLABs
 // are capped at the humongous thresold and we want to
 // ensure that we don't try to allocate a TLAB as
 // Determine if an object is dead, given only the object itself.
 // This will find the region to which the object belongs and
 // then call the region version of the same function.
-// Added if it is in permanent gen it isn't dead.
 // Added if it is NULL it isn't dead.
 bool is_obj_dead(const oop obj) const {
 const HeapRegion* hr = heap_region_containing(obj);
 if (hr == NULL) {
-if (Universe::heap()->is_in_permanent(obj))
+if (obj == NULL) return false;
-return false;
-else if (obj == NULL) return false;
 else return true;
 }
 else return is_obj_dead(obj, hr);
 }
 bool is_obj_ill(const oop obj) const {
 const HeapRegion* hr = heap_region_containing(obj);
 if (hr == NULL) {
-if (Universe::heap()->is_in_permanent(obj))
+if (obj == NULL) return false;
-return false;
-else if (obj == NULL) return false;
 else return true;
 }
 else return is_obj_ill(obj, hr);
 }
 HeapWord* obj = NULL;
 size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
 if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
 G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
 add_to_alloc_buffer_waste(alloc_buf->words_remaining());
-alloc_buf->flush_stats_and_retire(_g1h->stats_for_purpose(purpose),
+alloc_buf->retire(false /* end_of_gc */, false /* retain */);
-false /* end_of_gc */,
-false /* retain */);
 HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
 if (buf == NULL) return NULL; // Let caller handle allocation failure.
 // Otherwise.
 alloc_buf->set_word_size(gclab_word_size);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 6948:e522a00b91aa