jdk8-mips64-public/hotspot: comparison src/share/vm/memory/space.hpp

-:0b27f3512f9e
+:37f87013dfd8
 HeapWord* bottom() const         { return _bottom; }
 HeapWord* end() const            { return _end;    }
 virtual void set_bottom(HeapWord* value) { _bottom = value; }
 virtual void set_end(HeapWord* value)    { _end = value; }
-HeapWord* saved_mark_word() const  { return _saved_mark_word; }
+virtual HeapWord* saved_mark_word() const  { return _saved_mark_word; }
 void set_saved_mark_word(HeapWord* p) { _saved_mark_word = p; }
 MemRegionClosure* preconsumptionDirtyCardClosure() const {
 return _preconsumptionDirtyCardClosure;
 }
 // and after the call to save marks.
 virtual MemRegion used_region_at_save_marks() const {
 return MemRegion(bottom(), saved_mark_word());
 }
-// Initialization
+// Initialization.
+// "initialize" should be called once on a space, before it is used for
+// any purpose.  The "mr" arguments gives the bounds of the space, and
+// the "clear_space" argument should be true unless the memory in "mr" is
+// known to be zeroed.
 virtual void initialize(MemRegion mr, bool clear_space);
+// Sets the bounds (bottom and end) of the current space to those of "mr."
+void set_bounds(MemRegion mr);
+// The "clear" method must be called on a region that may have
+// had allocation performed in it, but is now to be considered empty.
 virtual void clear();
 // For detecting GC bugs.  Should only be called at GC boundaries, since
 // some unused space may be used as scratch space during GC's.
 // Default implementation does nothing. We also call this when expanding
 // If "p" is in the space, returns the address of the start of the
 // "block" that contains "p".  We say "block" instead of "object" since
 // some heaps may not pack objects densely; a chunk may either be an
 // object or a non-object.  If "p" is not in the space, return NULL.
-virtual HeapWord* block_start(const void* p) const = 0;
+virtual HeapWord* block_start_const(const void* p) const = 0;
+// The non-const version may have benevolent side effects on the data
+// structure supporting these calls, possibly speeding up future calls.
+// The default implementation, however, is simply to call the const
+// version.
+inline virtual HeapWord* block_start(const void* p);
 // Requires "addr" to be the start of a chunk, and returns its size.
 // "addr + size" is required to be the start of a new chunk, or the end
 // of the active area of the heap.
 virtual size_t block_size(const HeapWord* addr) const = 0;
 OopClosure* _cl;
 Space* _sp;
 CardTableModRefBS::PrecisionStyle _precision;
 HeapWord* _boundary;          // If non-NULL, process only non-NULL oops
 // pointing below boundary.
-HeapWord* _min_done;                // ObjHeadPreciseArray precision requires
+HeapWord* _min_done;          // ObjHeadPreciseArray precision requires
 // a downwards traversal; this is the
 // lowest location already done (or,
 // alternatively, the lowest address that
 // shouldn't be done again.  NULL means infinity.)
 NOT_PRODUCT(HeapWord* _last_bottom;)
+NOT_PRODUCT(HeapWord* _last_explicit_min_done;)
 // Get the actual top of the area on which the closure will
 // operate, given where the top is assumed to be (the end of the
 // memory region passed to do_MemRegion) and where the object
 // at the top is assumed to start. For example, an object may
 DirtyCardToOopClosure(Space* sp, OopClosure* cl,
 CardTableModRefBS::PrecisionStyle precision,
 HeapWord* boundary) :
 _sp(sp), _cl(cl), _precision(precision), _boundary(boundary),
 _min_done(NULL) {
-NOT_PRODUCT(_last_bottom = NULL;)
+NOT_PRODUCT(_last_bottom = NULL);
+NOT_PRODUCT(_last_explicit_min_done = NULL);
 }
 void do_MemRegion(MemRegion mr);
 void set_min_done(HeapWord* min_done) {
 _min_done = min_done;
+NOT_PRODUCT(_last_explicit_min_done = _min_done);
 }
 #ifndef PRODUCT
 void set_last_bottom(HeapWord* last_bottom) {
 _last_bottom = last_bottom;
 }
 HeapWord* _compaction_top;
 CompactibleSpace* _next_compaction_space;
 public:
 virtual void initialize(MemRegion mr, bool clear_space);
+virtual void clear();
 // Used temporarily during a compaction phase to hold the value
 // top should have when compaction is complete.
 HeapWord* compaction_top() const { return _compaction_top;    }
 "these are the only valid states during a mark sweep");           \
 if (block_is_obj(q) && oop(q)->is_gc_marked()) {                         \
 /* prefetch beyond q */                                                \
 Prefetch::write(q, interval);                                          \
 /* size_t size = oop(q)->size();  changing this for cms for perm gen */\
-size_t size = block_size(q);                                             \
+size_t size = block_size(q);                                           \
 compact_top = cp->space->forward(oop(q), size, cp, compact_top);       \
 q += size;                                                             \
 end_of_live = q;                                                       \
 } else {                                                                 \
 /* run over all the contiguous dead objects */                         \
 \
 /* save the compaction_top of the compaction space. */                     \
 cp->space->set_compaction_top(compact_top);                                \
 }
-#define SCAN_AND_ADJUST_POINTERS(adjust_obj_size) {                                \
+#define SCAN_AND_ADJUST_POINTERS(adjust_obj_size) {                             \
-/* adjust all the interior pointers to point at the new locations of objects        \
+/* adjust all the interior pointers to point at the new locations of objects  \
-* Used by MarkSweep::mark_sweep_phase3() */                                        \
+* Used by MarkSweep::mark_sweep_phase3() */                                  \
 \
-HeapWord* q = bottom();                                                        \
+HeapWord* q = bottom();                                                       \
-HeapWord* t = _end_of_live;  /* Established by "prepare_for_compaction". */        \
+HeapWord* t = _end_of_live;  /* Established by "prepare_for_compaction". */   \
 \
-assert(_first_dead <= _end_of_live, "Stands to reason, no?");                        \
+assert(_first_dead <= _end_of_live, "Stands to reason, no?");                 \
 \
-if (q < t && _first_dead > q &&                                                \
+if (q < t && _first_dead > q &&                                               \
 !oop(q)->is_gc_marked()) {                                                \
 /* we have a chunk of the space which hasn't moved and we've                \
 * reinitialized the mark word during the previous pass, so we can't        \
-* use is_gc_marked for the traversal. */                                        \
+* use is_gc_marked for the traversal. */                                   \
 HeapWord* end = _first_dead;                                                \
 \
-while (q < end) {                                                                \
+while (q < end) {                                                           \
-/* I originally tried to conjoin "block_start(q) == q" to the                \
+/* I originally tried to conjoin "block_start(q) == q" to the             \
-* assertion below, but that doesn't work, because you can't                \
+* assertion below, but that doesn't work, because you can't              \
-* accurately traverse previous objects to get to the current one                \
+* accurately traverse previous objects to get to the current one         \
-* after their pointers (including pointers into permGen) have been        \
+* after their pointers (including pointers into permGen) have been       \
-* updated, until the actual compaction is done.  dld, 4/00 */                \
+* updated, until the actual compaction is done.  dld, 4/00 */            \
-assert(block_is_obj(q),                                                        \
+assert(block_is_obj(q),                                                   \
-"should be at block boundaries, and should be looking at objs");        \
+"should be at block boundaries, and should be looking at objs");   \
 \
 VALIDATE_MARK_SWEEP_ONLY(MarkSweep::track_interior_pointers(oop(q)));     \
 \
-/* point all the oops to the new location */                                \
+/* point all the oops to the new location */                              \
-size_t size = oop(q)->adjust_pointers();                                        \
+size_t size = oop(q)->adjust_pointers();                                  \
-size = adjust_obj_size(size);                                                \
+size = adjust_obj_size(size);                                             \
 \
 VALIDATE_MARK_SWEEP_ONLY(MarkSweep::check_interior_pointers());           \
 \
 VALIDATE_MARK_SWEEP_ONLY(MarkSweep::validate_live_oop(oop(q), size));     \
 \
 q += size;                                                                \
-}                                                                                \
+}                                                                           \
 \
-if (_first_dead == t) {                                                        \
+if (_first_dead == t) {                                                     \
-q = t;                                                                        \
+q = t;                                                                    \
-} else {                                                                        \
+} else {                                                                    \
-/* $$$ This is funky.  Using this to read the previously written                \
+/* $$$ This is funky.  Using this to read the previously written          \
-* LiveRange.  See also use below. */                                        \
+* LiveRange.  See also use below. */                                     \
 q = (HeapWord*)oop(_first_dead)->mark()->decode_pointer();                \
-}                                                                                \
+}                                                                           \
-}                                                                                \
+}                                                                             \
 \
 const intx interval = PrefetchScanIntervalInBytes;                            \
 \
-debug_only(HeapWord* prev_q = NULL);                                                \
+debug_only(HeapWord* prev_q = NULL);                                          \
-while (q < t) {                                                                \
+while (q < t) {                                                               \
-/* prefetch beyond q */                                                        \
+/* prefetch beyond q */                                                     \
 Prefetch::write(q, interval);                                               \
-if (oop(q)->is_gc_marked()) {                                                \
+if (oop(q)->is_gc_marked()) {                                               \
-/* q is alive */                                                                \
+/* q is alive */                                                          \
 VALIDATE_MARK_SWEEP_ONLY(MarkSweep::track_interior_pointers(oop(q)));     \
-/* point all the oops to the new location */                                \
+/* point all the oops to the new location */                              \
-size_t size = oop(q)->adjust_pointers();                                        \
+size_t size = oop(q)->adjust_pointers();                                  \
-size = adjust_obj_size(size);                                                \
+size = adjust_obj_size(size);                                             \
-VALIDATE_MARK_SWEEP_ONLY(MarkSweep::check_interior_pointers());                \
+VALIDATE_MARK_SWEEP_ONLY(MarkSweep::check_interior_pointers());           \
 VALIDATE_MARK_SWEEP_ONLY(MarkSweep::validate_live_oop(oop(q), size));     \
-debug_only(prev_q = q);                                                        \
+debug_only(prev_q = q);                                                   \
 q += size;                                                                \
 } else {                                                                        \
 /* q is not a live object, so its mark should point at the next                \
 * live object */                                                                \
 debug_only(prev_q = q);                                                        \
 debug_only(prev_q = q);                                                        \
 q += size;                                                                \
 }                                                                                \
 }                                                                                \
 \
+/* Let's remember if we were empty before we did the compaction. */           \
+bool was_empty = used_region().is_empty();                                    \
 /* Reset space after compaction is complete */                                \
 reset_after_compaction();                                                        \
 /* We do this clear, below, since it has overloaded meanings for some */      \
 /* space subtypes.  For example, OffsetTableContigSpace's that were   */      \
 /* compacted into will have had their offset table thresholds updated */      \
 /* continuously, but those that weren't need to have their thresholds */      \
 /* re-initialized.  Also mangles unused area for debugging.           */      \
-if (is_empty()) {                                                             \
+if (used_region().is_empty()) {                                               \
-clear();                                                                    \
+if (!was_empty) clear();                                                    \
 } else {                                                                      \
 if (ZapUnusedHeapArea) mangle_unused_area();                                \
 }                                                                             \
 }
 // Accessors
 HeapWord* top() const            { return _top;    }
 void set_top(HeapWord* value)    { _top = value; }
-void set_saved_mark()       { _saved_mark_word = top();    }
+virtual void set_saved_mark()    { _saved_mark_word = top();    }
-void reset_saved_mark()     { _saved_mark_word = bottom(); }
+void reset_saved_mark()          { _saved_mark_word = bottom(); }
 virtual void clear();
 WaterMark bottom_mark()     { return WaterMark(this, bottom()); }
 WaterMark top_mark()        { return WaterMark(this, top()); }
 // to denote the start of an object.  Objects allocated by
 // applications of the closure *are* included in the iteration.
 virtual void object_iterate_from(WaterMark mark, ObjectClosure* blk);
 // Very inefficient implementation.
-virtual HeapWord* block_start(const void* p) const;
+virtual HeapWord* block_start_const(const void* p) const;
 size_t block_size(const HeapWord* p) const;
 // If a block is in the allocated area, it is an object.
 bool block_is_obj(const HeapWord* p) const { return p < top(); }
 // Addresses for inlined allocation
 MemRegion mr);
 void set_bottom(HeapWord* value);
 void set_end(HeapWord* value);
+virtual void initialize(MemRegion mr, bool clear_space);
 void clear();
-inline HeapWord* block_start(const void* p) const;
+inline HeapWord* block_start_const(const void* p) const;
 // Add offset table update.
 virtual inline HeapWord* allocate(size_t word_size);
 inline HeapWord* par_allocate(size_t word_size);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/space.hpp

src/share/vm/memory/space.hpp