1 /*
2 * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/vmClasses.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "gc/shared/blockOffsetTable.inline.hpp"
29 #include "gc/shared/collectedHeap.inline.hpp"
30 #include "gc/shared/genCollectedHeap.hpp"
31 #include "gc/shared/genOopClosures.inline.hpp"
32 #include "gc/shared/slidingForwarding.inline.hpp"
33 #include "gc/shared/space.hpp"
34 #include "gc/shared/space.inline.hpp"
35 #include "gc/shared/spaceDecorator.inline.hpp"
36 #include "memory/iterator.inline.hpp"
37 #include "memory/universe.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "runtime/atomic.hpp"
40 #include "runtime/java.hpp"
41 #include "runtime/prefetch.inline.hpp"
42 #include "runtime/safepoint.hpp"
43 #include "utilities/align.hpp"
44 #include "utilities/copy.hpp"
45 #include "utilities/globalDefinitions.hpp"
46 #include "utilities/macros.hpp"
47 #if INCLUDE_SERIALGC
48 #include "gc/serial/defNewGeneration.hpp"
49 #endif
50
51 HeapWord* DirtyCardToOopClosure::get_actual_top(HeapWord* top,
52 HeapWord* top_obj) {
53 if (top_obj != NULL) {
54 if (_sp->block_is_obj(top_obj)) {
55 if (_precision == CardTable::ObjHeadPreciseArray) {
56 if (cast_to_oop(top_obj)->is_objArray() || cast_to_oop(top_obj)->is_typeArray()) {
57 // An arrayOop is starting on the dirty card - since we do exact
58 // store checks for objArrays we are done.
59 } else {
60 // Otherwise, it is possible that the object starting on the dirty
61 // card spans the entire card, and that the store happened on a
62 // later card. Figure out where the object ends.
63 // Use the block_size() method of the space over which
64 // the iteration is being done. That space (e.g. CMS) may have
65 // specific requirements on object sizes which will
66 // be reflected in the block_size() method.
67 top = top_obj + cast_to_oop(top_obj)->size();
68 }
69 }
70 } else {
71 top = top_obj;
72 }
73 } else {
74 assert(top == _sp->end(), "only case where top_obj == NULL");
75 }
76 return top;
77 }
78
79 void DirtyCardToOopClosure::walk_mem_region(MemRegion mr,
80 HeapWord* bottom,
81 HeapWord* top) {
82 // 1. Blocks may or may not be objects.
83 // 2. Even when a block_is_obj(), it may not entirely
84 // occupy the block if the block quantum is larger than
85 // the object size.
86 // We can and should try to optimize by calling the non-MemRegion
87 // version of oop_iterate() for all but the extremal objects
88 // (for which we need to call the MemRegion version of
89 // oop_iterate()) To be done post-beta XXX
90 for (; bottom < top; bottom += _sp->block_size(bottom)) {
91 // As in the case of contiguous space above, we'd like to
92 // just use the value returned by oop_iterate to increment the
93 // current pointer; unfortunately, that won't work in CMS because
94 // we'd need an interface change (it seems) to have the space
95 // "adjust the object size" (for instance pad it up to its
96 // block alignment or minimum block size restrictions. XXX
97 if (_sp->block_is_obj(bottom) &&
98 !_sp->obj_allocated_since_save_marks(cast_to_oop(bottom))) {
99 cast_to_oop(bottom)->oop_iterate(_cl, mr);
100 }
101 }
102 }
103
104 // We get called with "mr" representing the dirty region
105 // that we want to process. Because of imprecise marking,
106 // we may need to extend the incoming "mr" to the right,
107 // and scan more. However, because we may already have
108 // scanned some of that extended region, we may need to
109 // trim its right-end back some so we do not scan what
110 // we (or another worker thread) may already have scanned
111 // or planning to scan.
112 void DirtyCardToOopClosure::do_MemRegion(MemRegion mr) {
113 HeapWord* bottom = mr.start();
114 HeapWord* last = mr.last();
115 HeapWord* top = mr.end();
116 HeapWord* bottom_obj;
117 HeapWord* top_obj;
118
119 assert(_precision == CardTable::ObjHeadPreciseArray ||
120 _precision == CardTable::Precise,
121 "Only ones we deal with for now.");
122
123 assert(_precision != CardTable::ObjHeadPreciseArray ||
124 _last_bottom == NULL || top <= _last_bottom,
125 "Not decreasing");
126 NOT_PRODUCT(_last_bottom = mr.start());
127
128 bottom_obj = _sp->block_start(bottom);
129 top_obj = _sp->block_start(last);
130
131 assert(bottom_obj <= bottom, "just checking");
132 assert(top_obj <= top, "just checking");
133
134 // Given what we think is the top of the memory region and
135 // the start of the object at the top, get the actual
136 // value of the top.
137 top = get_actual_top(top, top_obj);
138
139 // If the previous call did some part of this region, don't redo.
140 if (_precision == CardTable::ObjHeadPreciseArray &&
141 _min_done != NULL &&
142 _min_done < top) {
143 top = _min_done;
144 }
145
146 // Top may have been reset, and in fact may be below bottom,
147 // e.g. the dirty card region is entirely in a now free object
148 // -- something that could happen with a concurrent sweeper.
149 bottom = MIN2(bottom, top);
150 MemRegion extended_mr = MemRegion(bottom, top);
151 assert(bottom <= top &&
152 (_precision != CardTable::ObjHeadPreciseArray ||
153 _min_done == NULL ||
154 top <= _min_done),
155 "overlap!");
156
157 // Walk the region if it is not empty; otherwise there is nothing to do.
158 if (!extended_mr.is_empty()) {
159 walk_mem_region(extended_mr, bottom_obj, top);
160 }
161
162 _min_done = bottom;
163 }
164
165 DirtyCardToOopClosure* Space::new_dcto_cl(OopIterateClosure* cl,
166 CardTable::PrecisionStyle precision,
167 HeapWord* boundary) {
168 return new DirtyCardToOopClosure(this, cl, precision, boundary);
169 }
170
171 HeapWord* ContiguousSpaceDCTOC::get_actual_top(HeapWord* top,
172 HeapWord* top_obj) {
173 if (top_obj != NULL && top_obj < (_sp->toContiguousSpace())->top()) {
174 if (_precision == CardTable::ObjHeadPreciseArray) {
175 if (cast_to_oop(top_obj)->is_objArray() || cast_to_oop(top_obj)->is_typeArray()) {
176 // An arrayOop is starting on the dirty card - since we do exact
177 // store checks for objArrays we are done.
178 } else {
179 // Otherwise, it is possible that the object starting on the dirty
180 // card spans the entire card, and that the store happened on a
181 // later card. Figure out where the object ends.
182 assert(_sp->block_size(top_obj) == (size_t) cast_to_oop(top_obj)->size(),
183 "Block size and object size mismatch");
184 top = top_obj + cast_to_oop(top_obj)->size();
185 }
186 }
187 } else {
188 top = (_sp->toContiguousSpace())->top();
189 }
190 return top;
191 }
192
193 void FilteringDCTOC::walk_mem_region(MemRegion mr,
194 HeapWord* bottom,
195 HeapWord* top) {
196 // Note that this assumption won't hold if we have a concurrent
197 // collector in this space, which may have freed up objects after
198 // they were dirtied and before the stop-the-world GC that is
199 // examining cards here.
200 assert(bottom < top, "ought to be at least one obj on a dirty card.");
201
202 if (_boundary != NULL) {
203 // We have a boundary outside of which we don't want to look
204 // at objects, so create a filtering closure around the
205 // oop closure before walking the region.
206 FilteringClosure filter(_boundary, _cl);
207 walk_mem_region_with_cl(mr, bottom, top, &filter);
208 } else {
209 // No boundary, simply walk the heap with the oop closure.
210 walk_mem_region_with_cl(mr, bottom, top, _cl);
211 }
212
213 }
214
215 // We must replicate this so that the static type of "FilteringClosure"
216 // (see above) is apparent at the oop_iterate calls.
217 #define ContiguousSpaceDCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \
218 void ContiguousSpaceDCTOC::walk_mem_region_with_cl(MemRegion mr, \
219 HeapWord* bottom, \
220 HeapWord* top, \
221 ClosureType* cl) { \
222 bottom += cast_to_oop(bottom)->oop_iterate_size(cl, mr); \
223 if (bottom < top) { \
224 HeapWord* next_obj = bottom + cast_to_oop(bottom)->size(); \
225 while (next_obj < top) { \
226 /* Bottom lies entirely below top, so we can call the */ \
227 /* non-memRegion version of oop_iterate below. */ \
228 cast_to_oop(bottom)->oop_iterate(cl); \
229 bottom = next_obj; \
230 next_obj = bottom + cast_to_oop(bottom)->size(); \
231 } \
232 /* Last object. */ \
233 cast_to_oop(bottom)->oop_iterate(cl, mr); \
234 } \
235 }
236
237 // (There are only two of these, rather than N, because the split is due
238 // only to the introduction of the FilteringClosure, a local part of the
239 // impl of this abstraction.)
240 ContiguousSpaceDCTOC__walk_mem_region_with_cl_DEFN(OopIterateClosure)
241 ContiguousSpaceDCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure)
242
243 DirtyCardToOopClosure*
244 ContiguousSpace::new_dcto_cl(OopIterateClosure* cl,
245 CardTable::PrecisionStyle precision,
246 HeapWord* boundary) {
247 return new ContiguousSpaceDCTOC(this, cl, precision, boundary);
248 }
249
250 void Space::initialize(MemRegion mr,
251 bool clear_space,
252 bool mangle_space) {
253 HeapWord* bottom = mr.start();
254 HeapWord* end = mr.end();
255 assert(Universe::on_page_boundary(bottom) && Universe::on_page_boundary(end),
256 "invalid space boundaries");
257 set_bottom(bottom);
258 set_end(end);
259 if (clear_space) clear(mangle_space);
260 }
261
262 void Space::clear(bool mangle_space) {
263 if (ZapUnusedHeapArea && mangle_space) {
264 mangle_unused_area();
265 }
266 }
267
268 ContiguousSpace::ContiguousSpace(): CompactibleSpace(), _top(NULL) {
269 _mangler = new GenSpaceMangler(this);
270 }
271
272 ContiguousSpace::~ContiguousSpace() {
273 delete _mangler;
274 }
275
276 void ContiguousSpace::initialize(MemRegion mr,
277 bool clear_space,
278 bool mangle_space)
279 {
280 CompactibleSpace::initialize(mr, clear_space, mangle_space);
281 }
282
283 void ContiguousSpace::clear(bool mangle_space) {
284 set_top(bottom());
285 set_saved_mark();
286 CompactibleSpace::clear(mangle_space);
287 }
288
289 bool ContiguousSpace::is_free_block(const HeapWord* p) const {
290 return p >= _top;
291 }
292
293 void OffsetTableContigSpace::clear(bool mangle_space) {
294 ContiguousSpace::clear(mangle_space);
295 _offsets.initialize_threshold();
296 }
297
298 void OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) {
299 Space::set_bottom(new_bottom);
300 _offsets.set_bottom(new_bottom);
301 }
302
303 void OffsetTableContigSpace::set_end(HeapWord* new_end) {
304 // Space should not advertise an increase in size
305 // until after the underlying offset table has been enlarged.
306 _offsets.resize(pointer_delta(new_end, bottom()));
307 Space::set_end(new_end);
308 }
309
310 #ifndef PRODUCT
311
312 void ContiguousSpace::set_top_for_allocations(HeapWord* v) {
313 mangler()->set_top_for_allocations(v);
314 }
315 void ContiguousSpace::set_top_for_allocations() {
316 mangler()->set_top_for_allocations(top());
317 }
318 void ContiguousSpace::check_mangled_unused_area(HeapWord* limit) {
319 mangler()->check_mangled_unused_area(limit);
320 }
321
322 void ContiguousSpace::check_mangled_unused_area_complete() {
323 mangler()->check_mangled_unused_area_complete();
324 }
325
326 // Mangled only the unused space that has not previously
327 // been mangled and that has not been allocated since being
328 // mangled.
329 void ContiguousSpace::mangle_unused_area() {
330 mangler()->mangle_unused_area();
331 }
332 void ContiguousSpace::mangle_unused_area_complete() {
333 mangler()->mangle_unused_area_complete();
334 }
335 #endif // NOT_PRODUCT
336
337 void CompactibleSpace::initialize(MemRegion mr,
338 bool clear_space,
339 bool mangle_space) {
340 Space::initialize(mr, clear_space, mangle_space);
341 set_compaction_top(bottom());
342 _next_compaction_space = NULL;
343 }
344
345 void CompactibleSpace::clear(bool mangle_space) {
346 Space::clear(mangle_space);
347 _compaction_top = bottom();
348 }
349
350 HeapWord* CompactibleSpace::forward(oop q, size_t size,
351 CompactPoint* cp, HeapWord* compact_top, SlidingForwarding* const forwarding) {
352 // q is alive
353 // First check if we should switch compaction space
354 assert(this == cp->space, "'this' should be current compaction space.");
355 size_t compaction_max_size = pointer_delta(end(), compact_top);
356 while (size > compaction_max_size) {
357 // switch to next compaction space
358 cp->space->set_compaction_top(compact_top);
359 cp->space = cp->space->next_compaction_space();
360 if (cp->space == NULL) {
361 cp->gen = GenCollectedHeap::heap()->young_gen();
362 assert(cp->gen != NULL, "compaction must succeed");
363 cp->space = cp->gen->first_compaction_space();
364 assert(cp->space != NULL, "generation must have a first compaction space");
365 }
366 compact_top = cp->space->bottom();
367 cp->space->set_compaction_top(compact_top);
368 cp->threshold = cp->space->initialize_threshold();
369 compaction_max_size = pointer_delta(cp->space->end(), compact_top);
370 }
371
372 // store the forwarding pointer into the mark word
373 if (cast_from_oop<HeapWord*>(q) != compact_top) {
374 forwarding->forward_to(q, cast_to_oop(compact_top));
375 assert(q->is_gc_marked(), "encoding the pointer should preserve the mark");
376 } else {
377 // if the object isn't moving we can just set the mark to the default
378 // mark and handle it specially later on.
379 q->init_mark();
380 assert(!q->is_forwarded(), "should not be forwarded");
381 }
382
383 compact_top += size;
384
385 // we need to update the offset table so that the beginnings of objects can be
386 // found during scavenge. Note that we are updating the offset table based on
387 // where the object will be once the compaction phase finishes.
388 if (compact_top > cp->threshold)
389 cp->threshold =
390 cp->space->cross_threshold(compact_top - size, compact_top);
391 return compact_top;
392 }
393
394 #if INCLUDE_SERIALGC
395
396 void ContiguousSpace::prepare_for_compaction(CompactPoint* cp) {
397 scan_and_forward(this, cp);
398 }
399
400 void CompactibleSpace::adjust_pointers() {
401 // Check first is there is any work to do.
402 if (used() == 0) {
403 return; // Nothing to do.
404 }
405
406 scan_and_adjust_pointers(this);
407 }
408
409 void CompactibleSpace::compact() {
410 scan_and_compact(this);
411 }
412
413 #endif // INCLUDE_SERIALGC
414
415 void Space::print_short() const { print_short_on(tty); }
416
417 void Space::print_short_on(outputStream* st) const {
418 st->print(" space " SIZE_FORMAT "K, %3d%% used", capacity() / K,
419 (int) ((double) used() * 100 / capacity()));
420 }
421
422 void Space::print() const { print_on(tty); }
423
424 void Space::print_on(outputStream* st) const {
425 print_short_on(st);
426 st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ")",
427 p2i(bottom()), p2i(end()));
428 }
429
430 void ContiguousSpace::print_on(outputStream* st) const {
431 print_short_on(st);
432 st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
433 p2i(bottom()), p2i(top()), p2i(end()));
434 }
435
436 void OffsetTableContigSpace::print_on(outputStream* st) const {
437 print_short_on(st);
438 st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", "
439 INTPTR_FORMAT ", " INTPTR_FORMAT ")",
440 p2i(bottom()), p2i(top()), p2i(_offsets.threshold()), p2i(end()));
441 }
442
443 void ContiguousSpace::verify() const {
444 HeapWord* p = bottom();
445 HeapWord* t = top();
446 HeapWord* prev_p = NULL;
447 while (p < t) {
448 oopDesc::verify(cast_to_oop(p));
449 prev_p = p;
450 p += cast_to_oop(p)->size();
451 }
452 guarantee(p == top(), "end of last object must match end of space");
453 if (top() != end()) {
454 guarantee(top() == block_start_const(end()-1) &&
455 top() == block_start_const(top()),
456 "top should be start of unallocated block, if it exists");
457 }
458 }
459
460 void Space::oop_iterate(OopIterateClosure* blk) {
461 ObjectToOopClosure blk2(blk);
462 object_iterate(&blk2);
463 }
464
465 bool Space::obj_is_alive(const HeapWord* p) const {
466 assert (block_is_obj(p), "The address should point to an object");
467 return true;
468 }
469
470 void ContiguousSpace::oop_iterate(OopIterateClosure* blk) {
471 if (is_empty()) return;
472 HeapWord* obj_addr = bottom();
473 HeapWord* t = top();
474 // Could call objects iterate, but this is easier.
475 while (obj_addr < t) {
476 obj_addr += cast_to_oop(obj_addr)->oop_iterate_size(blk);
477 }
478 }
479
480 void ContiguousSpace::object_iterate(ObjectClosure* blk) {
481 if (is_empty()) return;
482 object_iterate_from(bottom(), blk);
483 }
484
485 void ContiguousSpace::object_iterate_from(HeapWord* mark, ObjectClosure* blk) {
486 while (mark < top()) {
487 blk->do_object(cast_to_oop(mark));
488 mark += cast_to_oop(mark)->size();
489 }
490 }
491
492 // Very general, slow implementation.
493 HeapWord* ContiguousSpace::block_start_const(const void* p) const {
494 assert(MemRegion(bottom(), end()).contains(p),
495 "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
496 p2i(p), p2i(bottom()), p2i(end()));
497 if (p >= top()) {
498 return top();
499 } else {
500 HeapWord* last = bottom();
501 HeapWord* cur = last;
502 while (cur <= p) {
503 last = cur;
504 cur += cast_to_oop(cur)->size();
505 }
506 assert(oopDesc::is_oop(cast_to_oop(last)), PTR_FORMAT " should be an object start", p2i(last));
507 return last;
508 }
509 }
510
511 size_t ContiguousSpace::block_size(const HeapWord* p) const {
512 assert(MemRegion(bottom(), end()).contains(p),
513 "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
514 p2i(p), p2i(bottom()), p2i(end()));
515 HeapWord* current_top = top();
516 assert(p <= current_top,
517 "p > current top - p: " PTR_FORMAT ", current top: " PTR_FORMAT,
518 p2i(p), p2i(current_top));
519 assert(p == current_top || oopDesc::is_oop(cast_to_oop(p)),
520 "p (" PTR_FORMAT ") is not a block start - "
521 "current_top: " PTR_FORMAT ", is_oop: %s",
522 p2i(p), p2i(current_top), BOOL_TO_STR(oopDesc::is_oop(cast_to_oop(p))));
523 if (p < current_top) {
524 return cast_to_oop(p)->size();
525 } else {
526 assert(p == current_top, "just checking");
527 return pointer_delta(end(), (HeapWord*) p);
528 }
529 }
530
531 // This version requires locking.
532 inline HeapWord* ContiguousSpace::allocate_impl(size_t size) {
533 assert(Heap_lock->owned_by_self() ||
534 (SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()),
535 "not locked");
536 HeapWord* obj = top();
537 if (pointer_delta(end(), obj) >= size) {
538 HeapWord* new_top = obj + size;
539 set_top(new_top);
540 assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
541 return obj;
542 } else {
543 return NULL;
544 }
545 }
546
547 // This version is lock-free.
548 inline HeapWord* ContiguousSpace::par_allocate_impl(size_t size) {
549 do {
550 HeapWord* obj = top();
551 if (pointer_delta(end(), obj) >= size) {
552 HeapWord* new_top = obj + size;
553 HeapWord* result = Atomic::cmpxchg(top_addr(), obj, new_top);
554 // result can be one of two:
555 // the old top value: the exchange succeeded
556 // otherwise: the new value of the top is returned.
557 if (result == obj) {
558 assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
559 return obj;
560 }
561 } else {
562 return NULL;
563 }
564 } while (true);
565 }
566
567 // Requires locking.
568 HeapWord* ContiguousSpace::allocate(size_t size) {
569 return allocate_impl(size);
570 }
571
572 // Lock-free.
573 HeapWord* ContiguousSpace::par_allocate(size_t size) {
574 return par_allocate_impl(size);
575 }
576
577 void ContiguousSpace::allocate_temporary_filler(int factor) {
578 // allocate temporary type array decreasing free size with factor 'factor'
579 assert(factor >= 0, "just checking");
580 size_t size = pointer_delta(end(), top());
581
582 // if space is full, return
583 if (size == 0) return;
584
585 if (factor > 0) {
586 size -= size/factor;
587 }
588 size = align_object_size(size);
589
590 const size_t array_header_size = (arrayOopDesc::base_offset_in_bytes(T_INT) + BytesPerWord) / BytesPerWord;
591 if (size >= align_object_size(array_header_size)) {
592 size_t length = (size - array_header_size) * (HeapWordSize / sizeof(jint));
593 // allocate uninitialized int array
594 typeArrayOop t = (typeArrayOop) cast_to_oop(allocate(size));
595 assert(t != NULL, "allocation should succeed");
596 #ifdef _LP64
597 t->set_mark(Universe::intArrayKlassObj()->prototype_header());
598 #else
599 t->set_mark(markWord::prototype());
600 t->set_klass(Universe::intArrayKlassObj());
601 #endif
602 t->set_length((int)length);
603 } else {
604 assert(size == CollectedHeap::min_fill_size(),
605 "size for smallest fake object doesn't match");
606 instanceOop obj = (instanceOop) cast_to_oop(allocate(size));
607 #ifdef _LP64
608 obj->set_mark(vmClasses::Object_klass()->prototype_header());
609 #else
610 obj->set_mark(markWord::prototype());
611 obj->set_klass(vmClasses::Object_klass());
612 #endif
613 }
614 }
615
616 HeapWord* OffsetTableContigSpace::initialize_threshold() {
617 return _offsets.initialize_threshold();
618 }
619
620 HeapWord* OffsetTableContigSpace::cross_threshold(HeapWord* start, HeapWord* end) {
621 _offsets.alloc_block(start, end);
622 return _offsets.threshold();
623 }
624
625 OffsetTableContigSpace::OffsetTableContigSpace(BlockOffsetSharedArray* sharedOffsetArray,
626 MemRegion mr) :
627 _offsets(sharedOffsetArray, mr),
628 _par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true)
629 {
630 _offsets.set_contig_space(this);
631 initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle);
632 }
633
634 #define OBJ_SAMPLE_INTERVAL 0
635 #define BLOCK_SAMPLE_INTERVAL 100
636
637 void OffsetTableContigSpace::verify() const {
638 HeapWord* p = bottom();
639 HeapWord* prev_p = NULL;
640 int objs = 0;
641 int blocks = 0;
642
643 if (VerifyObjectStartArray) {
644 _offsets.verify();
645 }
646
647 while (p < top()) {
648 size_t size = cast_to_oop(p)->size();
649 // For a sampling of objects in the space, find it using the
650 // block offset table.
651 if (blocks == BLOCK_SAMPLE_INTERVAL) {
652 guarantee(p == block_start_const(p + (size/2)),
653 "check offset computation");
654 blocks = 0;
655 } else {
656 blocks++;
657 }
658
659 if (objs == OBJ_SAMPLE_INTERVAL) {
660 oopDesc::verify(cast_to_oop(p));
661 objs = 0;
662 } else {
663 objs++;
664 }
665 prev_p = p;
666 p += size;
667 }
668 guarantee(p == top(), "end of last object must match end of space");
669 }
670
671
672 size_t TenuredSpace::allowed_dead_ratio() const {
673 return MarkSweepDeadRatio;
674 }