jdk-sandbox: comparison hotspot/src/share/vm/gc

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 //   ParallelScavengeHeap
 //
 class CollectedHeap : public CHeapObj<mtInternal> {
 friend class VMStructs;
 friend class IsGCActiveMark; // Block structured external access to _is_gc_active
-friend class constantPoolCacheKlass; // allocate() method inserts is_conc_safe
 #ifdef ASSERT
 static int       _fire_out_of_memory_count;
 #endif
 inline static HeapWord* common_mem_allocate_noinit(size_t size, TRAPS);
 // Like allocate_init, but the block returned by a successful allocation
 // is guaranteed initialized to zeros.
 inline static HeapWord* common_mem_allocate_init(size_t size, TRAPS);
-// Same as common_mem version, except memory is allocated in the permanent area
-// If there is no permanent area, revert to common_mem_allocate_noinit
-inline static HeapWord* common_permanent_mem_allocate_noinit(size_t size, TRAPS);
-// Same as common_mem version, except memory is allocated in the permanent area
-// If there is no permanent area, revert to common_mem_allocate_init
-inline static HeapWord* common_permanent_mem_allocate_init(size_t size, TRAPS);
 // Helper functions for (VM) allocation.
 inline static void post_allocation_setup_common(KlassHandle klass, HeapWord* obj);
 inline static void post_allocation_setup_no_klass_install(KlassHandle klass,
 HeapWord* objPtr);
 // Return "true" if the part of the heap that allocates Java
 // objects has reached the maximal committed limit that it can
 // reach, without a garbage collection.
 virtual bool is_maximal_no_gc() const = 0;
-virtual size_t permanent_capacity() const = 0;
-virtual size_t permanent_used() const = 0;
 // Support for java.lang.Runtime.maxMemory():  return the maximum amount of
 // memory that the vm could make available for storing 'normal' java objects.
 // This is based on the reserved address space, but should not include space
-// that the vm uses internally for bookkeeping or temporary storage (e.g.,
+// that the vm uses internally for bookkeeping or temporary storage
-// perm gen space or, in the case of the young gen, one of the survivor
+// (e.g., in the case of the young gen, one of the survivor
 // spaces).
 virtual size_t max_capacity() const = 0;
 // Returns "TRUE" if "p" points into the reserved area of the heap.
 bool is_in_reserved(const void* p) const {
 // use to assertion checking only.
 virtual bool is_in(const void* p) const = 0;
 bool is_in_or_null(const void* p) const {
 return p == NULL || is_in(p);
+}
+bool is_in_place(Metadata** p) {
+return !Universe::heap()->is_in(p);
+}
+bool is_in_place(oop* p) { return Universe::heap()->is_in(p); }
+bool is_in_place(narrowOop* p) {
+oop o = oopDesc::load_decode_heap_oop_not_null(p);
+return Universe::heap()->is_in((const void*)o);
 }
 // Let's define some terms: a "closed" subset of a heap is one that
 //
 // 1) contains all currently-allocated objects, and
 bool is_in_closed_subset_or_null(const void* p) const {
 return p == NULL || is_in_closed_subset(p);
 }
-// XXX is_permanent() and is_in_permanent() should be better named
-// to distinguish one from the other.
-// Returns "TRUE" if "p" is allocated as "permanent" data.
-// If the heap does not use "permanent" data, returns the same
-// value is_in_reserved() would return.
-// NOTE: this actually returns true if "p" is in reserved space
-// for the space not that it is actually allocated (i.e. in committed
-// space). If you need the more conservative answer use is_permanent().
-virtual bool is_in_permanent(const void *p) const = 0;
 #ifdef ASSERT
 // Returns true if "p" is in the part of the
 // heap being collected.
 virtual bool is_in_partial_collection(const void *p) = 0;
 #endif
-bool is_in_permanent_or_null(const void *p) const {
-return p == NULL || is_in_permanent(p);
-}
-// Returns "TRUE" if "p" is in the committed area of  "permanent" data.
-// If the heap does not use "permanent" data, returns the same
-// value is_in() would return.
-virtual bool is_permanent(const void *p) const = 0;
-bool is_permanent_or_null(const void *p) const {
-return p == NULL || is_permanent(p);
-}
 // An object is scavengable if its location may move during a scavenge.
 // (A scavenge is a GC which is not a full GC.)
 virtual bool is_scavengable(const void *p) = 0;
 // Returns "TRUE" if "p" is a method oop in the
 // current heap, with high probability. This predicate
 // is not stable, in general.
-bool is_valid_method(oop p) const;
+bool is_valid_method(Method* p) const;
 void set_gc_cause(GCCause::Cause v) {
 if (UsePerfData) {
 _gc_lastcause = _gc_cause;
 _perf_gc_lastcause->set_value(GCCause::to_string(_gc_lastcause));
 uint n_par_threads() { return _n_par_threads; }
 // May be overridden to set additional parallelism.
 virtual void set_par_threads(uint t) { _n_par_threads = t; };
-// Preload classes into the shared portion of the heap, and then dump
-// that data to a file so that it can be loaded directly by another
-// VM (then terminate).
-virtual void preload_and_dump(TRAPS) { ShouldNotReachHere(); }
 // Allocate and initialize instances of Class
 static oop Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS);
 // General obj/array allocation facilities.
 inline static oop obj_allocate(KlassHandle klass, int size, TRAPS);
 inline static oop array_allocate(KlassHandle klass, int size, int length, TRAPS);
 inline static oop array_allocate_nozero(KlassHandle klass, int size, int length, TRAPS);
-// Special obj/array allocation facilities.
+inline static void post_allocation_install_obj_klass(KlassHandle klass,
-// Some heaps may want to manage "permanent" data uniquely. These default
+oop obj);
-// to the general routines if the heap does not support such handling.
-inline static oop permanent_obj_allocate(KlassHandle klass, int size, TRAPS);
-// permanent_obj_allocate_no_klass_install() does not do the installation of
-// the klass pointer in the newly created object (as permanent_obj_allocate()
-// above does).  This allows for a delay in the installation of the klass
-// pointer that is needed during the create of klassKlass's.  The
-// method post_allocation_install_obj_klass() is used to install the
-// klass pointer.
-inline static oop permanent_obj_allocate_no_klass_install(KlassHandle klass,
-int size,
-TRAPS);
-inline static void post_allocation_install_obj_klass(KlassHandle klass, oop obj);
-inline static oop permanent_array_allocate(KlassHandle klass, int size, int length, TRAPS);
 // Raw memory allocation facilities
 // The obj and array allocate methods are covers for these methods.
-// The permanent allocation method should default to mem_allocate if
+// mem_allocate() should never be
-// permanent memory isn't supported. mem_allocate() should never be
 // called to allocate TLABs, only individual objects.
 virtual HeapWord* mem_allocate(size_t size,
 bool* gc_overhead_limit_was_exceeded) = 0;
-virtual HeapWord* permanent_mem_allocate(size_t size) = 0;
 // Utilities for turning raw memory into filler objects.
 //
 // min_fill_size() is the smallest region that can be filled.
 // fill_with_objects() can fill arbitrary-sized regions of the heap using
 // If the CollectedHeap was asked to defer a store barrier above,
 // this informs it to flush such a deferred store barrier to the
 // remembered set.
 virtual void flush_deferred_store_barrier(JavaThread* thread);
-// 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 = 0;
 // Does this heap support heap inspection (+PrintClassHistogram?)
 virtual bool supports_heap_inspection() const = 0;
 // Perform a collection of the heap; intended for use in implementing
 // "System.gc".  This probably implies as full a collection as the
 // "CollectedHeap" supports.
 virtual void collect(GCCause::Cause cause) = 0;
+// Perform a full collection
+virtual void do_full_collection(bool clear_all_soft_refs) = 0;
 // 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) = 0;
+virtual void collect_as_vm_thread(GCCause::Cause cause);
+// Callback from VM_CollectForMetadataAllocation operation.
+MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
+size_t size,
+Metaspace::MetadataType mdtype);
 // Returns the barrier set for this heap
 BarrierSet* barrier_set() { return _barrier_set; }
 // Returns "true" iff there is a stop-world GC in progress.  (I assume
 virtual AdaptiveSizePolicy* size_policy() = 0;
 // Return the CollectorPolicy for the heap
 virtual CollectorPolicy* collector_policy() const = 0;
+void oop_iterate_no_header(OopClosure* cl);
 // Iterate over all the ref-containing fields of all objects, calling
-// "cl.do_oop" on each. This includes objects in permanent memory.
+// "cl.do_oop" on each.
-virtual void oop_iterate(OopClosure* cl) = 0;
+virtual void oop_iterate(ExtendedOopClosure* cl) = 0;
 // Iterate over all objects, calling "cl.do_object" on each.
-// This includes objects in permanent memory.
 virtual void object_iterate(ObjectClosure* cl) = 0;
 // Similar to object_iterate() except iterates only
 // over live objects.
 virtual void safe_object_iterate(ObjectClosure* cl) = 0;
-// Behaves the same as oop_iterate, except only traverses
-// interior pointers contained in permanent memory. If there
-// is no permanent memory, does nothing.
-virtual void permanent_oop_iterate(OopClosure* cl) = 0;
-// Behaves the same as object_iterate, except only traverses
-// object contained in permanent memory. If there is no
-// permanent memory, does nothing.
-virtual void permanent_object_iterate(ObjectClosure* cl) = 0;
 // NOTE! There is no requirement that a collector implement these
 // functions.
 //
 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,

changeset 13728	882756847a04
parent 13195	be27e1b6a4b9
child 14579	7f6ce6e3dd80