jdk-sandbox: comparison hotspot/src/share/vm/memory/genCollectedHeap.hpp

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 friend class TenuredGeneration;
 friend class ConcurrentMarkSweepGeneration;
 friend class CMSCollector;
 friend class GenMarkSweep;
 friend class VM_GenCollectForAllocation;
-friend class VM_GenCollectForPermanentAllocation;
 friend class VM_GenCollectFull;
 friend class VM_GenCollectFullConcurrent;
 friend class VM_GC_HeapInspection;
 friend class VM_HeapDumper;
 friend class HeapInspection;
 SubTasksDone* gen_process_strong_tasks() { return _gen_process_strong_tasks; }
 // In block contents verification, the number of header words to skip
 NOT_PRODUCT(static size_t _skip_header_HeapWords;)
-// GC is not allowed during the dump of the shared classes.  Keep track
-// of this in order to provide an reasonable error message when terminating.
-bool _preloading_shared_classes;
 protected:
 // Directs each generation up to and including "collectedGen" to recompute
 // its desired size.
 void compute_new_generation_sizes(int collectedGen);
 // have handled it (including collection, expansion, etc.)
 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab);
 // Callback from VM_GenCollectFull operation.
 // Perform a full collection of the first max_level+1 generations.
+virtual void do_full_collection(bool clear_all_soft_refs);
 void do_full_collection(bool clear_all_soft_refs, int max_level);
 // Does the "cause" of GC indicate that
 // we absolutely __must__ clear soft refs?
 bool must_clear_all_soft_refs();
 GCStats* gc_stats(int level) const;
 // Returns JNI_OK on success
 virtual jint initialize();
-char* allocate(size_t alignment, PermanentGenerationSpec* perm_gen_spec,
+char* allocate(size_t alignment,
 size_t* _total_reserved, int* _n_covered_regions,
 ReservedSpace* heap_rs);
 // Does operations required after initialization has been done.
 void post_initialize();
 return CollectedHeap::GenCollectedHeap;
 }
 // The generational collector policy.
 GenCollectorPolicy* gen_policy() const { return _gen_policy; }
+virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) gen_policy(); }
 // Adaptive size policy
 virtual AdaptiveSizePolicy* size_policy() {
 return gen_policy()->size_policy();
 }
 size_t capacity() const;
 size_t used() const;
-// Save the "used_region" for generations level and lower,
+// Save the "used_region" for generations level and lower.
-// and, if perm is true, for perm gen.
+void save_used_regions(int level);
-void save_used_regions(int level, bool perm);
 size_t max_capacity() const;
 HeapWord* mem_allocate(size_t size,
 bool*  gc_overhead_limit_was_exceeded);
 // Perform a full collection of the heap; intended for use in implementing
 // "System.gc". This implies as full a collection as the CollectedHeap
 // supports. Caller does not hold the Heap_lock on entry.
 void collect(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.
-void collect_as_vm_thread(GCCause::Cause cause);
 // The same as above but assume that the caller holds the Heap_lock.
 void collect_locked(GCCause::Cause cause);
 // Perform a full collection of the first max_level+1 generations.
 // Mostly used for testing purposes. Caller does not hold the Heap_lock on entry.
 virtual bool is_scavengable(const void* addr) {
 return is_in_young((oop)addr);
 }
 // Iteration functions.
-void oop_iterate(OopClosure* cl);
+void oop_iterate(ExtendedOopClosure* cl);
-void oop_iterate(MemRegion mr, OopClosure* cl);
+void oop_iterate(MemRegion mr, ExtendedOopClosure* cl);
 void object_iterate(ObjectClosure* cl);
 void safe_object_iterate(ObjectClosure* cl);
 void object_iterate_since_last_GC(ObjectClosure* cl);
 Space* space_containing(const void* addr) const;
 // but unfortunately the flag UseSerialGC need not necessarily always
 // be set when DefNew+Tenured are being used.
 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 {
-// CMS needs to see all, even intra-generational, ref updates.
-return !UseConcMarkSweepGC;
-}
 // The "requestor" generation is performing some garbage collection
 // action for which it would be useful to have scratch space.  The
 // requestor promises to allocate no more than "max_alloc_words" in any
 // older generation (via promotion say.)   Any blocks of space that can
 // be provided are returned as a list of ScratchBlocks, sorted by
 // to "now".
 void update_time_of_last_gc(jlong now) {
 for (int i = 0; i < _n_gens; i++) {
 _gens[i]->update_time_of_last_gc(now);
 }
-perm_gen()->update_time_of_last_gc(now);
 }
 // Update the gc statistics for each generation.
 // "level" is the level of the lastest collection
 void update_gc_stats(int current_level, bool full) {
 for (int i = 0; i < _n_gens; i++) {
 _gens[i]->update_gc_stats(current_level, full);
 }
-perm_gen()->update_gc_stats(current_level, full);
 }
 // Override.
 bool no_gc_in_progress() { return !is_gc_active(); }
 virtual void gc_threads_do(ThreadClosure* tc) const;
 virtual void print_tracing_info() const;
 // PrintGC, PrintGCDetails support
 void print_heap_change(size_t prev_used) const;
-void print_perm_heap_change(size_t perm_prev_used) const;
 // The functions below are helper functions that a subclass of
 // "CollectedHeap" can use in the implementation of its virtual
 // functions.
 class GenClosure : public StackObj {
 public:
 virtual void do_generation(Generation* gen) = 0;
 };
-// Apply "cl.do_generation" to all generations in the heap (not including
+// Apply "cl.do_generation" to all generations in the heap
-// the permanent generation).  If "old_to_young" determines the order.
+// If "old_to_young" determines the order.
 void generation_iterate(GenClosure* cl, bool old_to_young);
 void space_iterate(SpaceClosure* cl);
-// Return "true" if all generations (but perm) have reached the
+// Return "true" if all generations have reached the
 // maximal committed limit that they can reach, without a garbage
 // collection.
 virtual bool is_maximal_no_gc() const;
 // Return the generation before "gen", or else NULL.
 // from older generations; "not_older_gens" is used everywhere else.)
 // If "younger_gens_as_roots" is false, younger generations are
 // not scanned as roots; in this case, the caller must be arranging to
 // scan the younger generations itself.  (For example, a generation might
 // explicitly mark reachable objects in younger generations, to avoid
-// excess storage retention.)  If "collecting_perm_gen" is false, then
+// excess storage retention.)
-// roots that may only contain references to permGen objects are not
+// The "so" argument determines which of the roots
-// scanned; instead, the older_gens closure is applied to all outgoing
-// references in the perm gen.  The "so" argument determines which of the 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 the StringTable.
 void gen_process_strong_roots(int level,
 bool younger_gens_as_roots,
 // The remaining arguments are in an order
 // consistent with SharedHeap::process_strong_roots:
 bool activate_scope,
-bool collecting_perm_gen,
+bool is_scavenging,
 SharedHeap::ScanningOption so,
 OopsInGenClosure* not_older_gens,
 bool do_code_roots,
-OopsInGenClosure* older_gens);
+OopsInGenClosure* older_gens,
+KlassClosure* klass_closure);
 // 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.
 void gen_process_weak_roots(OopClosure* root_closure,
 // in other generations, it should call this method.
 void save_marks();
 // Apply "cur->do_oop" or "older->do_oop" to all the oops in objects
 // allocated since the last call to save_marks in generations at or above
-// "level" (including the permanent generation.)  The "cur" closure is
+// "level".  The "cur" closure is
 // applied to references in the generation at "level", and the "older"
-// closure to older (and permanent) generations.
+// closure to older generations.
 #define GCH_SINCE_SAVE_MARKS_ITERATE_DECL(OopClosureType, nv_suffix)    \
 void oop_since_save_marks_iterate(int level,                          \
 OopClosureType* cur,                \
 OopClosureType* older);
 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL)
 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL
 // Returns "true" iff no allocations have occurred in any generation at
-// "level" or above (including the permanent generation) since the last
+// "level" or above since the last
 // call to "save_marks".
 bool no_allocs_since_save_marks(int level);
 // Returns true if an incremental collection is likely to fail.
 // We optionally consult the young gen, if asked to do so;
 }
 void clear_incremental_collection_failed() {
 _incremental_collection_failed = false;
 }
-// Promotion of obj into gen failed.  Try to promote obj to higher non-perm
+// Promotion of obj into gen failed.  Try to promote obj to higher
 // gens in ascending order; return the new location of obj if successful.
 // Otherwise, try expand-and-allocate for obj in each generation starting at
 // gen; return the new location of obj if successful.  Otherwise, return NULL.
 oop handle_failed_promotion(Generation* gen,
 oop obj,
 void record_gen_tops_before_GC() PRODUCT_RETURN;
 protected:
 virtual void gc_prologue(bool full);
 virtual void gc_epilogue(bool full);
-public:
-virtual void preload_and_dump(TRAPS) KERNEL_RETURN;
 };
 #endif // SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP

changeset 13728	882756847a04
parent 12379	2cf45b79ce3a
child 16685	41c34debcde0