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

equal deleted inserted replaced

-:f4edb0d9f109
+:21d113ecbf6a
 // Sizes are in HeapWords, unless indicated otherwise.
 static const size_t Log2ChunkSize;
 static const size_t ChunkSize;
 static const size_t ChunkSizeBytes;
 // Mask for the bits in a size_t to get an offset within a chunk.
 static const size_t ChunkSizeOffsetMask;
 // Mask for the bits in a pointer to get an offset within a chunk.
 static const size_t ChunkAddrOffsetMask;
 // Mask for the bits in a pointer to get the address of the start of a chunk.
 static const size_t ChunkAddrMask;
 static const size_t Log2BlockSize;
 static const size_t BlockSize;
 static const size_t BlockOffsetMask;
 // 'parity' of the first 1 bit in the Block:  a positive offset means the
 // first 1 bit marks the start of an object, a negative offset means the first
 // 1 bit marks the end of an object.
 class BlockData
 {
 public:
 typedef short int blk_ofs_t;
 blk_ofs_t offset() const { return _offset >= 0 ? _offset : -_offset; }
 blk_ofs_t raw_offset() const { return _offset; }
 void set_first_is_start_bit(bool v) { _first_is_start_bit = v; }
 bool first_is_end_bit() {
 assert(_set_phase > 0, "Not initialized");
 return !_first_is_start_bit;
 }
 private:
 blk_ofs_t _offset;
 // This is temporary until the mark_bitmap is separated into
 // a start bit array and an end bit array.
 bool      _first_is_start_bit;
 #ifdef ASSERT
 short     _set_phase;
 static short _cur_phase;
 public:
 static void set_cur_phase(short v) { _cur_phase = v; }
 #endif
 };
 public:
 perm_space_id, old_space_id, eden_space_id,
 from_space_id, to_space_id, last_space_id
 } SpaceId;
 public:
-// In line closure decls
+// Inline closure decls
 //
 class IsAliveClosure: public BoolObjectClosure {
 public:
-void do_object(oop p) { assert(false, "don't call"); }
+virtual void do_object(oop p);
-bool do_object_b(oop p) { return mark_bitmap()->is_marked(p); }
+virtual bool do_object_b(oop p);
 };
 class KeepAliveClosure: public OopClosure {
+private:
+ParCompactionManager* _compaction_manager;
+protected:
+template <class T> inline void do_oop_work(T* p);
+public:
+KeepAliveClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
+virtual void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
+};
+// Current unused
+class FollowRootClosure: public OopsInGenClosure {
+private:
 ParCompactionManager* _compaction_manager;
 public:
-KeepAliveClosure(ParCompactionManager* cm) {
+FollowRootClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
-_compaction_manager = cm;
+virtual void do_oop(oop* p);
-}
+virtual void do_oop(narrowOop* p);
-void do_oop(oop* p);
+virtual const bool do_nmethods() const { return true; }
 };
-class FollowRootClosure: public OopsInGenClosure{
+class FollowStackClosure: public VoidClosure {
+private:
 ParCompactionManager* _compaction_manager;
 public:
-FollowRootClosure(ParCompactionManager* cm) {
+FollowStackClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
-_compaction_manager = cm;
+virtual void do_void();
-}
-void do_oop(oop* p) { follow_root(_compaction_manager, p); }
-virtual const bool do_nmethods() const { return true; }
 };
-class FollowStackClosure: public VoidClosure {
-ParCompactionManager* _compaction_manager;
-public:
-FollowStackClosure(ParCompactionManager* cm) {
-_compaction_manager = cm;
-}
-void do_void() { follow_stack(_compaction_manager); }
-};
 class AdjustPointerClosure: public OopsInGenClosure {
+private:
 bool _is_root;
 public:
-AdjustPointerClosure(bool is_root) : _is_root(is_root) {}
+AdjustPointerClosure(bool is_root) : _is_root(is_root) { }
-void do_oop(oop* p) { adjust_pointer(p, _is_root); }
+virtual void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
 };
 // Closure for verifying update of pointers.  Does not
 // have any side effects.
 class VerifyUpdateClosure: public ParMarkBitMapClosure {
 friend class FollowStackClosure;
 friend class AdjustPointerClosure;
 friend class FollowRootClosure;
 friend class instanceKlassKlass;
 friend class RefProcTaskProxy;
-static void mark_and_push_internal(ParCompactionManager* cm, oop* p);
 private:
 static elapsedTimer         _accumulated_time;
 static unsigned int         _total_invocations;
 static unsigned int         _maximum_compaction_gc_num;
 static bool   _dwl_initialized;
 #endif  // #ifdef ASSERT
 private:
 // Closure accessors
-static OopClosure* adjust_pointer_closure() { return (OopClosure*)&_adjust_pointer_closure; }
+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 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 marking_phase(ParCompactionManager* cm,
 bool maximum_heap_compaction);
 static void follow_stack(ParCompactionManager* cm);
 static void follow_weak_klass_links(ParCompactionManager* cm);
-static void adjust_pointer(oop* p, bool is_root);
+template <class T> static inline void adjust_pointer(T* p, bool is_root);
 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); }
-static void follow_root(ParCompactionManager* cm, oop* p);
+template <class T>
+static inline void follow_root(ParCompactionManager* cm, T* p);
 // Compute the dense prefix for the designated space.  This is an experimental
 // implementation currently not used in production.
 static HeapWord* compute_dense_prefix_via_density(const SpaceId id,
 bool maximum_compaction);
 // Reset time since last full gc
 static void reset_millis_since_last_gc();
 protected:
 #ifdef VALIDATE_MARK_SWEEP
-static GrowableArray<oop*>*            _root_refs_stack;
+static GrowableArray<void*>*           _root_refs_stack;
 static GrowableArray<oop> *            _live_oops;
 static GrowableArray<oop> *            _live_oops_moved_to;
 static GrowableArray<size_t>*          _live_oops_size;
 static size_t                          _live_oops_index;
 static size_t                          _live_oops_index_at_perm;
-static GrowableArray<oop*>*            _other_refs_stack;
+static GrowableArray<void*>*           _other_refs_stack;
-static GrowableArray<oop*>*            _adjusted_pointers;
+static GrowableArray<void*>*           _adjusted_pointers;
 static bool                            _pointer_tracking;
 static bool                            _root_tracking;
 // The following arrays are saved since the time of the last GC and
 // assist in tracking down problems where someone has done an errant
 static GrowableArray<size_t>*          _last_gc_live_oops_size;
 #endif
 public:
 class MarkAndPushClosure: public OopClosure {
+private:
 ParCompactionManager* _compaction_manager;
 public:
-MarkAndPushClosure(ParCompactionManager* cm) {
+MarkAndPushClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
-_compaction_manager = cm;
+virtual void do_oop(oop* p);
-}
+virtual void do_oop(narrowOop* p);
-void do_oop(oop* p) { mark_and_push(_compaction_manager, p); }
 virtual const bool do_nmethods() const { return true; }
 };
 PSParallelCompact();
 return _updated_int_array_klass_obj;
 }
 // Marking support
 static inline bool mark_obj(oop obj);
-static bool mark_obj(oop* p)  {
+// Check mark and maybe push on marking stack
-if (*p != NULL) {
+template <class T> static inline void mark_and_push(ParCompactionManager* cm,
-return mark_obj(*p);
+T* p);
-} else {
-return false;
-}
-}
-static void mark_and_push(ParCompactionManager* cm, oop* p) {
-// Check mark and maybe push on
-// marking stack
-oop m = *p;
-if (m != NULL && mark_bitmap()->is_unmarked(m)) {
-mark_and_push_internal(cm, p);
-}
-}
 // 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);
 // Update the deferred objects in the space.
 static void update_deferred_objects(ParCompactionManager* cm, SpaceId id);
 // Mark pointer and follow contents.
-static void mark_and_follow(ParCompactionManager* cm, oop* p);
+template <class T>
+static inline void mark_and_follow(ParCompactionManager* cm, T* p);
 static ParMarkBitMap* mark_bitmap() { return &_mark_bitmap; }
 static ParallelCompactData& summary_data() { return _summary_data; }
-static inline void adjust_pointer(oop* p) { adjust_pointer(p, false); }
+static inline void adjust_pointer(oop* p)       { adjust_pointer(p, false); }
-static inline void adjust_pointer(oop* p,
+static inline void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); }
+template <class T>
+static inline void adjust_pointer(T* p,
 HeapWord* beg_addr,
 HeapWord* end_addr);
 // Reference Processing
 static ReferenceProcessor* const ref_processor() { return _ref_processor; }
 // Time since last full gc (in milliseconds).
 static jlong millis_since_last_gc();
 #ifdef VALIDATE_MARK_SWEEP
-static void track_adjusted_pointer(oop* p, oop newobj, bool isroot);
+static void track_adjusted_pointer(void* p, bool isroot);
-static void check_adjust_pointer(oop* p);     // Adjust this pointer
+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 register_live_oop(oop p, size_t size);
 // Verify that all the chunks have been emptied.
 static void verify_complete(SpaceId space_id);
 #endif  // #ifdef ASSERT
 };
-bool PSParallelCompact::mark_obj(oop obj) {
+inline bool PSParallelCompact::mark_obj(oop obj) {
 const int obj_size = obj->size();
 if (mark_bitmap()->mark_obj(obj, obj_size)) {
 _summary_data.add_obj(obj, obj_size);
 return true;
 } else {
 return false;
 }
 }
-inline bool PSParallelCompact::print_phases()
+template <class T>
-{
+inline void PSParallelCompact::follow_root(ParCompactionManager* cm, T* p) {
+assert(!Universe::heap()->is_in_reserved(p),
+"roots shouldn't be things within the heap");
+#ifdef VALIDATE_MARK_SWEEP
+if (ValidateMarkSweep) {
+guarantee(!_root_refs_stack->contains(p), "should only be in here once");
+_root_refs_stack->push(p);
+}
+#endif
+T heap_oop = oopDesc::load_heap_oop(p);
+if (!oopDesc::is_null(heap_oop)) {
+oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
+if (mark_bitmap()->is_unmarked(obj)) {
+if (mark_obj(obj)) {
+obj->follow_contents(cm);
+}
+}
+}
+follow_stack(cm);
+}
+template <class T>
+inline void PSParallelCompact::mark_and_follow(ParCompactionManager* cm,
+T* p) {
+T heap_oop = oopDesc::load_heap_oop(p);
+if (!oopDesc::is_null(heap_oop)) {
+oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
+if (mark_bitmap()->is_unmarked(obj)) {
+if (mark_obj(obj)) {
+obj->follow_contents(cm);
+}
+}
+}
+}
+template <class T>
+inline void PSParallelCompact::mark_and_push(ParCompactionManager* cm, T* p) {
+T heap_oop = oopDesc::load_heap_oop(p);
+if (!oopDesc::is_null(heap_oop)) {
+oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
+if (mark_bitmap()->is_unmarked(obj)) {
+if (mark_obj(obj)) {
+// This thread marked the object and owns the subsequent processing of it.
+cm->save_for_scanning(obj);
+}
+}
+}
+}
+template <class T>
+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?
+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");
+oopDesc::encode_store_heap_oop_not_null(p, new_obj);
+}
+}
+VALIDATE_MARK_SWEEP_ONLY(track_adjusted_pointer(p, isroot));
+}
+template <class T>
+inline void PSParallelCompact::KeepAliveClosure::do_oop_work(T* p) {
+#ifdef VALIDATE_MARK_SWEEP
+if (ValidateMarkSweep) {
+if (!Universe::heap()->is_in_reserved(p)) {
+_root_refs_stack->push(p);
+} else {
+_other_refs_stack->push(p);
+}
+}
+#endif
+mark_and_push(_compaction_manager, p);
+}
+inline bool PSParallelCompact::print_phases() {
 return _print_phases;
 }
-inline double PSParallelCompact::normal_distribution(double density)
+inline double PSParallelCompact::normal_distribution(double density) {
-{
 assert(_dwl_initialized, "uninitialized");
 const double squared_term = (density - _dwl_mean) / _dwl_std_dev;
 return _dwl_first_term * exp(-0.5 * squared_term * squared_term);
 }
 inline bool PSParallelCompact::should_update_klass(klassOop k) {
 return ((HeapWord*) k) >= dense_prefix(perm_space_id);
 }
-inline void PSParallelCompact::adjust_pointer(oop* p,
+template <class T>
+inline void PSParallelCompact::adjust_pointer(T* p,
 HeapWord* beg_addr,
 HeapWord* end_addr) {
-if (is_in(p, beg_addr, end_addr)) {
+if (is_in((HeapWord*)p, beg_addr, end_addr)) {
 adjust_pointer(p);
 }
 }
 class MoveAndUpdateClosure: public ParMarkBitMapClosure {
 virtual IterationStatus do_addr(HeapWord* addr, size_t words);
 inline void do_addr(HeapWord* addr);
 };
-inline void UpdateOnlyClosure::do_addr(HeapWord* addr) {
+inline void UpdateOnlyClosure::do_addr(HeapWord* addr)
+{
 _start_array->allocate_block(addr);
 oop(addr)->update_contents(compaction_manager());
 }
 class FillClosure: public ParMarkBitMapClosure {
 public:
-FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id):
+FillClosure(ParCompactionManager* cm, PSParallelCompact::SpaceId space_id) :
 ParMarkBitMapClosure(PSParallelCompact::mark_bitmap(), cm),
 _space_id(space_id),
-_start_array(PSParallelCompact::start_array(space_id))
+_start_array(PSParallelCompact::start_array(space_id)) {
-{
 assert(_space_id == PSParallelCompact::perm_space_id ||
 _space_id == PSParallelCompact::old_space_id,
 "cannot use FillClosure in the young gen");
 assert(bitmap() != NULL, "need a bitmap");
 assert(_start_array != NULL, "need a start array");

changeset 360	21d113ecbf6a
parent 1	489c9b5090e2
child 971	f0b20be4165d
child 670	ddf3e9583f2f