truffle: src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp comparison

comparison src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	ab4422d0ed59
children	aed758eda82a

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 class ParallelScavengeHeap;
 class PSAdaptiveSizePolicy;
 class PSYoungGen;
 class PSOldGen;
-class PSPermGen;
 class ParCompactionManager;
 class ParallelTaskTerminator;
 class PSParallelCompact;
 class GCTaskManager;
 class GCTaskQueue;
 HeapWord* calc_new_pointer(oop p) {
 return calc_new_pointer((HeapWord*) p);
 }
-// Return the updated address for the given klass
-klassOop calc_new_klass(klassOop);
 #ifdef  ASSERT
 void verify_clear(const PSVirtualSpace* vspace);
 void verify_clear();
 #endif  // #ifdef ASSERT
 // Convenient access to type names.
 typedef ParMarkBitMap::idx_t idx_t;
 typedef ParallelCompactData::RegionData RegionData;
 typedef enum {
-perm_space_id, old_space_id, eden_space_id,
+old_space_id, eden_space_id,
 from_space_id, to_space_id, last_space_id
 } SpaceId;
 public:
 // Inline closure decls
 public:
 FollowStackClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
 virtual void do_void();
 };
-class AdjustPointerClosure: public OopsInGenClosure {
+class AdjustPointerClosure: public OopClosure {
 private:
 bool _is_root;
 public:
 AdjustPointerClosure(bool is_root) : _is_root(is_root) { }
 virtual void do_oop(oop* p);
 virtual void do_oop(narrowOop* p);
 // do not walk from thread stacks to the code cache on this phase
 virtual void do_code_blob(CodeBlob* cb) const { }
 };
+class AdjustKlassClosure : public KlassClosure {
+public:
+void do_klass(Klass* klass);
+};
 friend class KeepAliveClosure;
 friend class FollowStackClosure;
 friend class AdjustPointerClosure;
+friend class AdjustKlassClosure;
+friend class FollowKlassClosure;
 friend class FollowRootClosure;
-friend class instanceKlassKlass;
+friend class instanceClassLoaderKlass;
 friend class RefProcTaskProxy;
 private:
 static elapsedTimer         _accumulated_time;
 static unsigned int         _total_invocations;
 static IsAliveClosure       _is_alive_closure;
 static SpaceInfo            _space_info[last_space_id];
 static bool                 _print_phases;
 static AdjustPointerClosure _adjust_root_pointer_closure;
 static AdjustPointerClosure _adjust_pointer_closure;
+static AdjustKlassClosure   _adjust_klass_closure;
 // Reference processing (used in ...follow_contents)
 static ReferenceProcessor*  _ref_processor;
 // Updated location of intArrayKlassObj.
-static klassOop _updated_int_array_klass_obj;
+static Klass* _updated_int_array_klass_obj;
 // Values computed at initialization and used by dead_wood_limiter().
 static double _dwl_mean;
 static double _dwl_std_dev;
 static double _dwl_first_term;
 #ifdef  ASSERT
 static bool   _dwl_initialized;
 #endif  // #ifdef ASSERT
 private:
-// Closure accessors
-static OopClosure* adjust_pointer_closure()      { return (OopClosure*)&_adjust_pointer_closure; }
-static OopClosure* adjust_root_pointer_closure() { return (OopClosure*)&_adjust_root_pointer_closure; }
-static BoolObjectClosure* is_alive_closure()     { return (BoolObjectClosure*)&_is_alive_closure; }
 static void initialize_space_info();
 // Return true if details about individual phases should be printed.
 static inline bool print_phases();
 static void post_compact();
 // Mark live objects
 static void marking_phase(ParCompactionManager* cm,
 bool maximum_heap_compaction);
-static void follow_weak_klass_links();
-static void follow_mdo_weak_refs();
 template <class T> static inline void adjust_pointer(T* p, bool is_root);
 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); }
 template <class T>
 static void summarize_space(SpaceId id, bool maximum_compaction);
 static void summary_phase(ParCompactionManager* cm, bool maximum_compaction);
 // Adjust addresses in roots.  Does not adjust addresses in heap.
 static void adjust_roots();
-// Serial code executed in preparation for the compaction phase.
-static void compact_prologue();
 // Move objects to new locations.
 static void compact_perm(ParCompactionManager* cm);
 static void compact();
 MarkAndPushClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
 virtual void do_oop(oop* p);
 virtual void do_oop(narrowOop* p);
 };
+// The one and only place to start following the classes.
+// Should only be applied to the ClassLoaderData klasses list.
+class FollowKlassClosure : public KlassClosure {
+private:
+MarkAndPushClosure* _mark_and_push_closure;
+public:
+FollowKlassClosure(MarkAndPushClosure* mark_and_push_closure) :
+_mark_and_push_closure(mark_and_push_closure) { }
+void do_klass(Klass* klass);
+};
 PSParallelCompact();
 // Convenient accessor for Universe::heap().
 static ParallelScavengeHeap* gc_heap() {
 return (ParallelScavengeHeap*)Universe::heap();
 // allocations.  This should be called during the VM initialization
 // at a pointer where it would be appropriate to return a JNI_ENOMEM
 // in the event of a failure.
 static bool initialize();
+// Closure accessors
+static OopClosure* adjust_pointer_closure()      { return (OopClosure*)&_adjust_pointer_closure; }
+static OopClosure* adjust_root_pointer_closure() { return (OopClosure*)&_adjust_root_pointer_closure; }
+static KlassClosure* adjust_klass_closure()      { return (KlassClosure*)&_adjust_klass_closure; }
+static BoolObjectClosure* is_alive_closure()     { return (BoolObjectClosure*)&_is_alive_closure; }
 // Public accessors
 static elapsedTimer* accumulated_time() { return &_accumulated_time; }
 static unsigned int total_invocations() { return _total_invocations; }
 static CollectorCounters* counters()    { return _counters; }
 // Used to add tasks
 static GCTaskManager* const gc_task_manager();
-static klassOop updated_int_array_klass_obj() {
+static Klass* updated_int_array_klass_obj() {
 return _updated_int_array_klass_obj;
 }
 // Marking support
 static inline bool mark_obj(oop obj);
+static inline bool is_marked(oop obj);
 // Check mark and maybe push on marking stack
 template <class T> static inline void mark_and_push(ParCompactionManager* cm,
 T* p);
+static void follow_klass(ParCompactionManager* cm, Klass* klass);
+static void adjust_klass(ParCompactionManager* cm, Klass* klass);
+static void follow_class_loader(ParCompactionManager* cm,
+ClassLoaderData* klass);
+static void adjust_class_loader(ParCompactionManager* cm,
+ClassLoaderData* klass);
 // Compaction support.
 // Return true if p is in the range [beg_addr, end_addr).
 static inline bool is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr);
 static inline bool is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr);
 // Convenience wrappers for per-space data kept in _space_info.
 static inline MutableSpace*     space(SpaceId space_id);
 static inline HeapWord*         new_top(SpaceId space_id);
 static inline HeapWord*         dense_prefix(SpaceId space_id);
 static inline ObjectStartArray* start_array(SpaceId space_id);
-// Return true if the klass should be updated.
-static inline bool should_update_klass(klassOop k);
 // Move and update the live objects in the specified space.
 static void move_and_update(ParCompactionManager* cm, SpaceId space_id);
 // Process the end of the given region range in the dense prefix.
 static void track_adjusted_pointer(void* p, bool isroot);
 static void check_adjust_pointer(void* p);
 static void track_interior_pointers(oop obj);
 static void check_interior_pointers();
-static void reset_live_oop_tracking(bool at_perm);
+static void reset_live_oop_tracking();
 static void register_live_oop(oop p, size_t size);
 static void validate_live_oop(oop p, size_t size);
 static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top);
 static void compaction_complete();
 // Finds and prints the current base oop and offset for a word
 // within an oop that was live during the last GC. Helpful for
 // tracking down heap stomps.
 static void print_new_location_of_heap_address(HeapWord* q);
 #endif  // #ifdef VALIDATE_MARK_SWEEP
-// Call backs for class unloading
-// Update subklass/sibling/implementor links at end of marking.
-static void revisit_weak_klass_link(ParCompactionManager* cm, Klass* k);
-// Clear unmarked oops in MDOs at the end of marking.
-static void revisit_mdo(ParCompactionManager* cm, DataLayout* p);
 #ifndef PRODUCT
 // Debugging support.
 static const char* space_names[last_space_id];
 static void print_region_ranges();
 _summary_data.add_obj(obj, obj_size);
 return true;
 } else {
 return false;
 }
+}
+inline bool PSParallelCompact::is_marked(oop obj) {
+return mark_bitmap()->is_marked(obj);
 }
 template <class T>
 inline void PSParallelCompact::follow_root(ParCompactionManager* cm, T* p) {
 assert(!Universe::heap()->is_in_reserved(p),
 inline void PSParallelCompact::adjust_pointer(T* p, bool isroot) {
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop obj     = oopDesc::decode_heap_oop_not_null(heap_oop);
 oop new_obj = (oop)summary_data().calc_new_pointer(obj);
-assert(new_obj != NULL ||                     // is forwarding ptr?
+assert(new_obj != NULL,                    // is forwarding ptr?
-obj->is_shared(),                      // never forwarded?
 "should be forwarded");
 // Just always do the update unconditionally?
 if (new_obj != NULL) {
 assert(Universe::heap()->is_in_reserved(new_obj),
 "should be in object space");
 inline ObjectStartArray* PSParallelCompact::start_array(SpaceId id) {
 assert(id < last_space_id, "id out of range");
 return _space_info[id].start_array();
 }
-inline bool PSParallelCompact::should_update_klass(klassOop k) {
-return ((HeapWord*) k) >= dense_prefix(perm_space_id);
-}
 #ifdef ASSERT
 inline void
 PSParallelCompact::check_new_location(HeapWord* old_addr, HeapWord* new_addr)
 {
 assert(old_addr >= new_addr || space_id(old_addr) != space_id(new_addr),
 public:
 FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id) :
 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm),
 _start_array(PSParallelCompact::start_array(space_id))
 {
-assert(space_id == PSParallelCompact::perm_space_id ||
+assert(space_id == PSParallelCompact::old_space_id,
-space_id == PSParallelCompact::old_space_id,
 "cannot use FillClosure in the young gen");
 }
 virtual IterationStatus do_addr(HeapWord* addr, size_t size) {
 CollectedHeap::fill_with_objects(addr, size);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp @ 6725:da91efe96a93