jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARALLELSCAVENGEHEAP_HPP
 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
 #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
-#include "gc_implementation/parallelScavenge/psPermGen.hpp"
 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
 #include "gc_implementation/shared/gcPolicyCounters.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "utilities/ostream.hpp"
 class ParallelScavengeHeap : public CollectedHeap {
 friend class VMStructs;
 private:
 static PSYoungGen* _young_gen;
 static PSOldGen*   _old_gen;
-static PSPermGen*  _perm_gen;
 // Sizing policy for entire heap
 static PSAdaptiveSizePolicy* _size_policy;
 static PSGCAdaptivePolicyCounters*   _gc_policy_counters;
 static ParallelScavengeHeap* _psh;
-size_t _perm_gen_alignment;
 size_t _young_gen_alignment;
 size_t _old_gen_alignment;
 GenerationSizer* _collector_policy;
 HeapWord* mem_allocate_old_gen(size_t size);
 public:
 ParallelScavengeHeap() : CollectedHeap() {
 _death_march_count = 0;
-set_alignment(_perm_gen_alignment, intra_heap_alignment());
 set_alignment(_young_gen_alignment, intra_heap_alignment());
 set_alignment(_old_gen_alignment, intra_heap_alignment());
 }
 // For use by VM operations
 ParallelScavengeHeap::Name kind() const {
 return CollectedHeap::ParallelScavengeHeap;
 }
-CollectorPolicy* collector_policy() const { return (CollectorPolicy*) _collector_policy; }
+virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) _collector_policy; }
-// GenerationSizer* collector_policy() const { return _collector_policy; }
 static PSYoungGen* young_gen()     { return _young_gen; }
 static PSOldGen* old_gen()         { return _old_gen; }
-static PSPermGen* perm_gen()       { return _perm_gen; }
 virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; }
 static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
 virtual jint initialize();
 void post_initialize();
 void update_counters();
 // The alignment used for the various generations.
-size_t perm_gen_alignment()  const { return _perm_gen_alignment; }
 size_t young_gen_alignment() const { return _young_gen_alignment; }
 size_t old_gen_alignment()  const { return _old_gen_alignment; }
 // The alignment used for eden and survivors within the young gen
 // and for boundary between young gen and old gen.
 size_t intra_heap_alignment() const { return 64 * K; }
 size_t capacity() const;
 size_t used() const;
-// 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 true if the reference points to an object that
 virtual bool is_scavengable(const void* addr);
 // Does this heap support heap inspection? (+PrintClassHistogram)
 bool supports_heap_inspection() const { return true; }
-size_t permanent_capacity() const;
-size_t permanent_used() const;
 size_t max_capacity() const;
 // Whether p is in the allocated part of the heap
 bool is_in(const void* p) const;
 bool is_in_reserved(const void* p) const;
-bool is_in_permanent(const void *p) const {    // reserved part
-return perm_gen()->reserved().contains(p);
-}
 #ifdef ASSERT
 virtual bool is_in_partial_collection(const void *p);
 #endif
-bool is_permanent(const void *p) const {    // committed part
+bool is_in_young(oop p);        // reserved part
-return perm_gen()->is_in(p);
+bool is_in_old(oop p);          // reserved part
-}
-inline bool is_in_young(oop p);        // reserved part
-inline bool is_in_old_or_perm(oop p);  // reserved part
 // Memory allocation.   "gc_time_limit_was_exceeded" will
 // be set to true if the adaptive size policy determine that
 // an excessive amount of time is being spent doing collections
 // and caused a NULL to be returned.  If a NULL is not returned,
 // Allocation attempt(s) during a safepoint. It should never be called
 // to allocate a new TLAB as this allocation might be satisfied out
 // of the old generation.
 HeapWord* failed_mem_allocate(size_t size);
-HeapWord* permanent_mem_allocate(size_t size);
-HeapWord* failed_permanent_mem_allocate(size_t size);
 // Support for System.gc()
 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);
 // These also should be called by the vm thread at a safepoint (e.g., from a
 // VM operation).
 //
 // The first collects the young generation only, unless the scavenge fails; it
 // will then attempt a full gc.  The second collects the entire heap; if
 // maximum_compaction is true, it will compact everything and clear all soft
 // references.
 inline void invoke_scavenge();
-inline void invoke_full_gc(bool maximum_compaction);
+// Perform a full collection
+virtual void do_full_collection(bool clear_all_soft_refs);
 bool supports_inline_contig_alloc() const { return !UseNUMA; }
 HeapWord** top_addr() const { return !UseNUMA ? young_gen()->top_addr() : (HeapWord**)-1; }
 HeapWord** end_addr() const { return !UseNUMA ? young_gen()->end_addr() : (HeapWord**)-1; }
 // Return true if we don't we need a store barrier for
 // initializing stores to an object at this address.
 virtual bool can_elide_initializing_store_barrier(oop new_obj);
-// Can a compiler elide a store barrier when it writes
+void oop_iterate(ExtendedOopClosure* cl);
-// 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 {
-return true;
-}
-void oop_iterate(OopClosure* cl);
 void object_iterate(ObjectClosure* cl);
 void safe_object_iterate(ObjectClosure* cl) { object_iterate(cl); }
-void permanent_oop_iterate(OopClosure* cl);
-void permanent_object_iterate(ObjectClosure* cl);
 HeapWord* block_start(const void* addr) const;
 size_t block_size(const HeapWord* addr) const;
 bool block_is_obj(const HeapWord* addr) const;

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