< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahHeapRegion.cpp

Print this page

  1 /*
  2  * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2013, 2019, Red Hat, Inc. All rights reserved.

  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  *
 24  */
 25 
 26 #include "precompiled.hpp"

 27 #include "gc/shared/space.hpp"
 28 #include "gc/shared/tlab_globals.hpp"


 29 #include "gc/shenandoah/shenandoahHeapRegionSet.inline.hpp"
 30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 31 #include "gc/shenandoah/shenandoahHeapRegion.hpp"
 32 #include "gc/shenandoah/shenandoahMarkingContext.inline.hpp"




 33 #include "jfr/jfrEvents.hpp"
 34 #include "memory/allocation.hpp"
 35 #include "memory/iterator.inline.hpp"
 36 #include "memory/resourceArea.hpp"
 37 #include "memory/universe.hpp"
 38 #include "oops/oop.inline.hpp"
 39 #include "runtime/atomic.hpp"
 40 #include "runtime/globals_extension.hpp"
 41 #include "runtime/java.hpp"
 42 #include "runtime/mutexLocker.hpp"
 43 #include "runtime/os.hpp"
 44 #include "runtime/safepoint.hpp"
 45 #include "utilities/powerOfTwo.hpp"
 46 

 47 size_t ShenandoahHeapRegion::RegionCount = 0;
 48 size_t ShenandoahHeapRegion::RegionSizeBytes = 0;
 49 size_t ShenandoahHeapRegion::RegionSizeWords = 0;
 50 size_t ShenandoahHeapRegion::RegionSizeBytesShift = 0;
 51 size_t ShenandoahHeapRegion::RegionSizeWordsShift = 0;
 52 size_t ShenandoahHeapRegion::RegionSizeBytesMask = 0;
 53 size_t ShenandoahHeapRegion::RegionSizeWordsMask = 0;
 54 size_t ShenandoahHeapRegion::HumongousThresholdBytes = 0;
 55 size_t ShenandoahHeapRegion::HumongousThresholdWords = 0;
 56 size_t ShenandoahHeapRegion::MaxTLABSizeBytes = 0;
 57 size_t ShenandoahHeapRegion::MaxTLABSizeWords = 0;
 58 
 59 ShenandoahHeapRegion::ShenandoahHeapRegion(HeapWord* start, size_t index, bool committed) :
 60   _index(index),
 61   _bottom(start),
 62   _end(start + RegionSizeWords),
 63   _new_top(nullptr),
 64   _empty_time(os::elapsedTime()),

 65   _state(committed ? _empty_committed : _empty_uncommitted),
 66   _top(start),
 67   _tlab_allocs(0),
 68   _gclab_allocs(0),

 69   _live_data(0),
 70   _critical_pins(0),
 71   _update_watermark(start) {





 72 
 73   assert(Universe::on_page_boundary(_bottom) && Universe::on_page_boundary(_end),
 74          "invalid space boundaries");
 75   if (ZapUnusedHeapArea && committed) {
 76     SpaceMangler::mangle_region(MemRegion(_bottom, _end));
 77   }
 78 }
 79 
 80 void ShenandoahHeapRegion::report_illegal_transition(const char *method) {
 81   stringStream ss;
 82   ss.print("Illegal region state transition from \"%s\", at %s\n  ", region_state_to_string(_state), method);
 83   print_on(&ss);
 84   fatal("%s", ss.freeze());
 85 }
 86 
 87 void ShenandoahHeapRegion::make_regular_allocation() {
 88   shenandoah_assert_heaplocked();
 89 
 90   switch (_state) {
 91     case _empty_uncommitted:
 92       do_commit();
 93     case _empty_committed:

 94       set_state(_regular);
 95     case _regular:
 96     case _pinned:
 97       return;
 98     default:
 99       report_illegal_transition("regular allocation");
100   }
101 }
102 






























103 void ShenandoahHeapRegion::make_regular_bypass() {
104   shenandoah_assert_heaplocked();
105   assert (ShenandoahHeap::heap()->is_full_gc_in_progress() || ShenandoahHeap::heap()->is_degenerated_gc_in_progress(),
106           "only for full or degen GC");
107 
108   switch (_state) {
109     case _empty_uncommitted:
110       do_commit();
111     case _empty_committed:
112     case _cset:
113     case _humongous_start:
114     case _humongous_cont:
115       set_state(_regular);
116       return;
117     case _pinned_cset:
118       set_state(_pinned);
119       return;
120     case _regular:
121     case _pinned:
122       return;
123     default:
124       report_illegal_transition("regular bypass");
125   }
126 }
127 
128 void ShenandoahHeapRegion::make_humongous_start() {
129   shenandoah_assert_heaplocked();

130   switch (_state) {
131     case _empty_uncommitted:
132       do_commit();
133     case _empty_committed:
134       set_state(_humongous_start);
135       return;
136     default:
137       report_illegal_transition("humongous start allocation");
138   }
139 }
140 
141 void ShenandoahHeapRegion::make_humongous_start_bypass() {
142   shenandoah_assert_heaplocked();
143   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
144 


145   switch (_state) {
146     case _empty_committed:
147     case _regular:
148     case _humongous_start:
149     case _humongous_cont:
150       set_state(_humongous_start);
151       return;
152     default:
153       report_illegal_transition("humongous start bypass");
154   }
155 }
156 
157 void ShenandoahHeapRegion::make_humongous_cont() {
158   shenandoah_assert_heaplocked();

159   switch (_state) {
160     case _empty_uncommitted:
161       do_commit();
162     case _empty_committed:
163      set_state(_humongous_cont);
164       return;
165     default:
166       report_illegal_transition("humongous continuation allocation");
167   }
168 }
169 
170 void ShenandoahHeapRegion::make_humongous_cont_bypass() {
171   shenandoah_assert_heaplocked();
172   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
173 


174   switch (_state) {
175     case _empty_committed:
176     case _regular:
177     case _humongous_start:
178     case _humongous_cont:
179       set_state(_humongous_cont);
180       return;
181     default:
182       report_illegal_transition("humongous continuation bypass");
183   }
184 }
185 
186 void ShenandoahHeapRegion::make_pinned() {
187   shenandoah_assert_heaplocked();
188   assert(pin_count() > 0, "Should have pins: " SIZE_FORMAT, pin_count());
189 
190   switch (_state) {
191     case _regular:
192       set_state(_pinned);
193     case _pinned_cset:
194     case _pinned:
195       return;
196     case _humongous_start:
197       set_state(_pinned_humongous_start);
198     case _pinned_humongous_start:
199       return;
200     case _cset:
201       _state = _pinned_cset;
202       return;
203     default:
204       report_illegal_transition("pinning");
205   }
206 }
207 
208 void ShenandoahHeapRegion::make_unpinned() {
209   shenandoah_assert_heaplocked();
210   assert(pin_count() == 0, "Should not have pins: " SIZE_FORMAT, pin_count());
211 
212   switch (_state) {
213     case _pinned:

214       set_state(_regular);
215       return;
216     case _regular:
217     case _humongous_start:
218       return;
219     case _pinned_cset:
220       set_state(_cset);
221       return;
222     case _pinned_humongous_start:
223       set_state(_humongous_start);
224       return;
225     default:
226       report_illegal_transition("unpinning");
227   }
228 }
229 
230 void ShenandoahHeapRegion::make_cset() {
231   shenandoah_assert_heaplocked();

232   switch (_state) {
233     case _regular:
234       set_state(_cset);
235     case _cset:
236       return;
237     default:
238       report_illegal_transition("cset");
239   }
240 }
241 
242 void ShenandoahHeapRegion::make_trash() {
243   shenandoah_assert_heaplocked();

244   switch (_state) {
245     case _cset:
246       // Reclaiming cset regions
247     case _humongous_start:
248     case _humongous_cont:
249       // Reclaiming humongous regions






250     case _regular:
251       // Immediate region reclaim
252       set_state(_trash);
253       return;
254     default:
255       report_illegal_transition("trashing");
256   }
257 }
258 
259 void ShenandoahHeapRegion::make_trash_immediate() {
260   make_trash();
261 
262   // On this path, we know there are no marked objects in the region,
263   // tell marking context about it to bypass bitmap resets.
264   ShenandoahHeap::heap()->complete_marking_context()->reset_top_bitmap(this);

265 }
266 
267 void ShenandoahHeapRegion::make_empty() {
268   shenandoah_assert_heaplocked();


269   switch (_state) {
270     case _trash:
271       set_state(_empty_committed);
272       _empty_time = os::elapsedTime();
273       return;
274     default:
275       report_illegal_transition("emptying");
276   }
277 }
278 
279 void ShenandoahHeapRegion::make_uncommitted() {
280   shenandoah_assert_heaplocked();
281   switch (_state) {
282     case _empty_committed:
283       do_uncommit();
284       set_state(_empty_uncommitted);
285       return;
286     default:
287       report_illegal_transition("uncommiting");
288   }
289 }
290 
291 void ShenandoahHeapRegion::make_committed_bypass() {
292   shenandoah_assert_heaplocked();
293   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
294 
295   switch (_state) {
296     case _empty_uncommitted:
297       do_commit();
298       set_state(_empty_committed);
299       return;
300     default:
301       report_illegal_transition("commit bypass");
302   }
303 }
304 
305 void ShenandoahHeapRegion::reset_alloc_metadata() {
306   _tlab_allocs = 0;
307   _gclab_allocs = 0;

308 }
309 
310 size_t ShenandoahHeapRegion::get_shared_allocs() const {
311   return used() - (_tlab_allocs + _gclab_allocs) * HeapWordSize;
312 }
313 
314 size_t ShenandoahHeapRegion::get_tlab_allocs() const {
315   return _tlab_allocs * HeapWordSize;
316 }
317 
318 size_t ShenandoahHeapRegion::get_gclab_allocs() const {
319   return _gclab_allocs * HeapWordSize;
320 }
321 




322 void ShenandoahHeapRegion::set_live_data(size_t s) {
323   assert(Thread::current()->is_VM_thread(), "by VM thread");
324   _live_data = (s >> LogHeapWordSize);
325 }
326 
327 void ShenandoahHeapRegion::print_on(outputStream* st) const {
328   st->print("|");
329   st->print(SIZE_FORMAT_W(5), this->_index);
330 
331   switch (_state) {
332     case _empty_uncommitted:
333       st->print("|EU ");
334       break;
335     case _empty_committed:
336       st->print("|EC ");
337       break;
338     case _regular:
339       st->print("|R  ");
340       break;
341     case _humongous_start:

346       break;
347     case _humongous_cont:
348       st->print("|HC ");
349       break;
350     case _cset:
351       st->print("|CS ");
352       break;
353     case _trash:
354       st->print("|TR ");
355       break;
356     case _pinned:
357       st->print("|P  ");
358       break;
359     case _pinned_cset:
360       st->print("|CSP");
361       break;
362     default:
363       ShouldNotReachHere();
364   }
365 


366 #define SHR_PTR_FORMAT "%12" PRIxPTR
367 
368   st->print("|BTE " SHR_PTR_FORMAT  ", " SHR_PTR_FORMAT ", " SHR_PTR_FORMAT,
369             p2i(bottom()), p2i(top()), p2i(end()));
370   st->print("|TAMS " SHR_PTR_FORMAT,
371             p2i(ShenandoahHeap::heap()->marking_context()->top_at_mark_start(const_cast<ShenandoahHeapRegion*>(this))));
372   st->print("|UWM " SHR_PTR_FORMAT,
373             p2i(_update_watermark));
374   st->print("|U " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(used()),                proper_unit_for_byte_size(used()));
375   st->print("|T " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_tlab_allocs()),     proper_unit_for_byte_size(get_tlab_allocs()));
376   st->print("|G " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_gclab_allocs()),    proper_unit_for_byte_size(get_gclab_allocs()));



377   st->print("|S " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_shared_allocs()),   proper_unit_for_byte_size(get_shared_allocs()));
378   st->print("|L " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_live_data_bytes()), proper_unit_for_byte_size(get_live_data_bytes()));
379   st->print("|CP " SIZE_FORMAT_W(3), pin_count());
380   st->cr();
381 
382 #undef SHR_PTR_FORMAT
383 }
384 
385 void ShenandoahHeapRegion::oop_iterate(OopIterateClosure* blk) {
386   if (!is_active()) return;
387   if (is_humongous()) {
388     oop_iterate_humongous(blk);
389   } else {
390     oop_iterate_objects(blk);




391   }
392 }
393 
394 void ShenandoahHeapRegion::oop_iterate_objects(OopIterateClosure* blk) {
395   assert(! is_humongous(), "no humongous region here");
396   HeapWord* obj_addr = bottom();
397   HeapWord* t = top();
398   // Could call objects iterate, but this is easier.












399   while (obj_addr < t) {
400     oop obj = cast_to_oop(obj_addr);
401     obj_addr += obj->oop_iterate_size(blk);



















402   }



403 }
404 
405 void ShenandoahHeapRegion::oop_iterate_humongous(OopIterateClosure* blk) {




406   assert(is_humongous(), "only humongous region here");


407   // Find head.
408   ShenandoahHeapRegion* r = humongous_start_region();
409   assert(r->is_humongous_start(), "need humongous head here");



410   oop obj = cast_to_oop(r->bottom());
411   obj->oop_iterate(blk, MemRegion(bottom(), top()));























412 }
413 
414 ShenandoahHeapRegion* ShenandoahHeapRegion::humongous_start_region() const {
415   ShenandoahHeap* heap = ShenandoahHeap::heap();
416   assert(is_humongous(), "Must be a part of the humongous region");
417   size_t i = index();
418   ShenandoahHeapRegion* r = const_cast<ShenandoahHeapRegion*>(this);
419   while (!r->is_humongous_start()) {
420     assert(i > 0, "Sanity");
421     i--;
422     r = heap->get_region(i);
423     assert(r->is_humongous(), "Must be a part of the humongous region");
424   }
425   assert(r->is_humongous_start(), "Must be");
426   return r;
427 }
428 
429 void ShenandoahHeapRegion::recycle() {







430   set_top(bottom());
431   clear_live_data();
432 
433   reset_alloc_metadata();
434 
435   ShenandoahHeap::heap()->marking_context()->reset_top_at_mark_start(this);
436   set_update_watermark(bottom());
437 
438   make_empty();
439 

440   if (ZapUnusedHeapArea) {
441     SpaceMangler::mangle_region(MemRegion(bottom(), end()));
442   }
443 }
444 
445 HeapWord* ShenandoahHeapRegion::block_start(const void* p) const {
446   assert(MemRegion(bottom(), end()).contains(p),
447          "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
448          p2i(p), p2i(bottom()), p2i(end()));
449   if (p >= top()) {
450     return top();
451   } else {
452     HeapWord* last = bottom();
453     HeapWord* cur = last;
454     while (cur <= p) {
455       last = cur;
456       cur += cast_to_oop(cur)->size();
457     }
458     shenandoah_assert_correct(nullptr, cast_to_oop(last));
459     return last;

463 size_t ShenandoahHeapRegion::block_size(const HeapWord* p) const {
464   assert(MemRegion(bottom(), end()).contains(p),
465          "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
466          p2i(p), p2i(bottom()), p2i(end()));
467   if (p < top()) {
468     return cast_to_oop(p)->size();
469   } else {
470     assert(p == top(), "just checking");
471     return pointer_delta(end(), (HeapWord*) p);
472   }
473 }
474 
475 size_t ShenandoahHeapRegion::setup_sizes(size_t max_heap_size) {
476   // Absolute minimums we should not ever break.
477   static const size_t MIN_REGION_SIZE = 256*K;
478 
479   if (FLAG_IS_DEFAULT(ShenandoahMinRegionSize)) {
480     FLAG_SET_DEFAULT(ShenandoahMinRegionSize, MIN_REGION_SIZE);
481   }
482 





483   size_t region_size;
484   if (FLAG_IS_DEFAULT(ShenandoahRegionSize)) {
485     if (ShenandoahMinRegionSize > max_heap_size / MIN_NUM_REGIONS) {
486       err_msg message("Max heap size (" SIZE_FORMAT "%s) is too low to afford the minimum number "
487                       "of regions (" SIZE_FORMAT ") of minimum region size (" SIZE_FORMAT "%s).",
488                       byte_size_in_proper_unit(max_heap_size), proper_unit_for_byte_size(max_heap_size),
489                       MIN_NUM_REGIONS,
490                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize));
491       vm_exit_during_initialization("Invalid -XX:ShenandoahMinRegionSize option", message);
492     }
493     if (ShenandoahMinRegionSize < MIN_REGION_SIZE) {
494       err_msg message("" SIZE_FORMAT "%s should not be lower than minimum region size (" SIZE_FORMAT "%s).",
495                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize),
496                       byte_size_in_proper_unit(MIN_REGION_SIZE),         proper_unit_for_byte_size(MIN_REGION_SIZE));
497       vm_exit_during_initialization("Invalid -XX:ShenandoahMinRegionSize option", message);
498     }
499     if (ShenandoahMinRegionSize < MinTLABSize) {
500       err_msg message("" SIZE_FORMAT "%s should not be lower than TLAB size size (" SIZE_FORMAT "%s).",
501                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize),
502                       byte_size_in_proper_unit(MinTLABSize),             proper_unit_for_byte_size(MinTLABSize));

651     evt.set_used(used());
652     evt.set_from(_state);
653     evt.set_to(to);
654     evt.commit();
655   }
656   _state = to;
657 }
658 
659 void ShenandoahHeapRegion::record_pin() {
660   Atomic::add(&_critical_pins, (size_t)1);
661 }
662 
663 void ShenandoahHeapRegion::record_unpin() {
664   assert(pin_count() > 0, "Region " SIZE_FORMAT " should have non-zero pins", index());
665   Atomic::sub(&_critical_pins, (size_t)1);
666 }
667 
668 size_t ShenandoahHeapRegion::pin_count() const {
669   return Atomic::load(&_critical_pins);
670 }

































































  1 /*
  2  * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2013, 2020, Red Hat, Inc. All rights reserved.
  4  * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
  5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  6  *
  7  * This code is free software; you can redistribute it and/or modify it
  8  * under the terms of the GNU General Public License version 2 only, as
  9  * published by the Free Software Foundation.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  *
 25  */
 26 
 27 #include "precompiled.hpp"
 28 #include "gc/shared/cardTable.hpp"
 29 #include "gc/shared/space.hpp"
 30 #include "gc/shared/tlab_globals.hpp"
 31 #include "gc/shenandoah/shenandoahCardTable.hpp"
 32 #include "gc/shenandoah/shenandoahFreeSet.hpp"
 33 #include "gc/shenandoah/shenandoahHeapRegionSet.inline.hpp"
 34 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 35 #include "gc/shenandoah/shenandoahHeapRegion.hpp"
 36 #include "gc/shenandoah/shenandoahMarkingContext.inline.hpp"
 37 #include "gc/shenandoah/shenandoahOldGeneration.hpp"
 38 #include "gc/shenandoah/shenandoahGeneration.hpp"
 39 #include "gc/shenandoah/shenandoahYoungGeneration.hpp"
 40 #include "gc/shenandoah/shenandoahScanRemembered.inline.hpp"
 41 #include "jfr/jfrEvents.hpp"
 42 #include "memory/allocation.hpp"
 43 #include "memory/iterator.inline.hpp"
 44 #include "memory/resourceArea.hpp"
 45 #include "memory/universe.hpp"
 46 #include "oops/oop.inline.hpp"
 47 #include "runtime/atomic.hpp"
 48 #include "runtime/globals_extension.hpp"
 49 #include "runtime/java.hpp"
 50 #include "runtime/mutexLocker.hpp"
 51 #include "runtime/os.hpp"
 52 #include "runtime/safepoint.hpp"
 53 #include "utilities/powerOfTwo.hpp"
 54 
 55 
 56 size_t ShenandoahHeapRegion::RegionCount = 0;
 57 size_t ShenandoahHeapRegion::RegionSizeBytes = 0;
 58 size_t ShenandoahHeapRegion::RegionSizeWords = 0;
 59 size_t ShenandoahHeapRegion::RegionSizeBytesShift = 0;
 60 size_t ShenandoahHeapRegion::RegionSizeWordsShift = 0;
 61 size_t ShenandoahHeapRegion::RegionSizeBytesMask = 0;
 62 size_t ShenandoahHeapRegion::RegionSizeWordsMask = 0;
 63 size_t ShenandoahHeapRegion::HumongousThresholdBytes = 0;
 64 size_t ShenandoahHeapRegion::HumongousThresholdWords = 0;
 65 size_t ShenandoahHeapRegion::MaxTLABSizeBytes = 0;
 66 size_t ShenandoahHeapRegion::MaxTLABSizeWords = 0;
 67 
 68 ShenandoahHeapRegion::ShenandoahHeapRegion(HeapWord* start, size_t index, bool committed) :
 69   _index(index),
 70   _bottom(start),
 71   _end(start + RegionSizeWords),
 72   _new_top(nullptr),
 73   _empty_time(os::elapsedTime()),
 74   _top_before_promoted(nullptr),
 75   _state(committed ? _empty_committed : _empty_uncommitted),
 76   _top(start),
 77   _tlab_allocs(0),
 78   _gclab_allocs(0),
 79   _plab_allocs(0),
 80   _live_data(0),
 81   _critical_pins(0),
 82   _update_watermark(start),
 83   _age(0)
 84 #ifdef SHENANDOAH_CENSUS_NOISE
 85   , _youth(0)
 86 #endif // SHENANDOAH_CENSUS_NOISE
 87   {
 88 
 89   assert(Universe::on_page_boundary(_bottom) && Universe::on_page_boundary(_end),
 90          "invalid space boundaries");
 91   if (ZapUnusedHeapArea && committed) {
 92     SpaceMangler::mangle_region(MemRegion(_bottom, _end));
 93   }
 94 }
 95 
 96 void ShenandoahHeapRegion::report_illegal_transition(const char *method) {
 97   stringStream ss;
 98   ss.print("Illegal region state transition from \"%s\", at %s\n  ", region_state_to_string(_state), method);
 99   print_on(&ss);
100   fatal("%s", ss.freeze());
101 }
102 
103 void ShenandoahHeapRegion::make_regular_allocation(ShenandoahAffiliation affiliation) {
104   shenandoah_assert_heaplocked();
105   reset_age();
106   switch (_state) {
107     case _empty_uncommitted:
108       do_commit();
109     case _empty_committed:
110       assert(this->affiliation() == affiliation, "Region affiliation should already be established");
111       set_state(_regular);
112     case _regular:
113     case _pinned:
114       return;
115     default:
116       report_illegal_transition("regular allocation");
117   }
118 }
119 
120 // Change affiliation to YOUNG_GENERATION if _state is not _pinned_cset, _regular, or _pinned.  This implements
121 // behavior previously performed as a side effect of make_regular_bypass().
122 void ShenandoahHeapRegion::make_young_maybe() {
123   shenandoah_assert_heaplocked();
124   switch (_state) {
125    case _empty_uncommitted:
126    case _empty_committed:
127    case _cset:
128    case _humongous_start:
129    case _humongous_cont:
130      if (affiliation() != YOUNG_GENERATION) {
131        ShenandoahHeap* heap = ShenandoahHeap::heap();
132        if (heap->mode()->is_generational()) {
133          if (is_old()) {
134            heap->old_generation()->decrement_affiliated_region_count();
135          }
136          heap->young_generation()->increment_affiliated_region_count();
137        }
138        set_affiliation(YOUNG_GENERATION);
139      }
140      return;
141    case _pinned_cset:
142    case _regular:
143    case _pinned:
144      return;
145    default:
146      assert(false, "Unexpected _state in make_young_maybe");
147   }
148 }
149 
150 void ShenandoahHeapRegion::make_regular_bypass() {
151   shenandoah_assert_heaplocked();
152   assert (ShenandoahHeap::heap()->is_full_gc_in_progress() || ShenandoahHeap::heap()->is_degenerated_gc_in_progress(),
153           "only for full or degen GC");
154   reset_age();
155   switch (_state) {
156     case _empty_uncommitted:
157       do_commit();
158     case _empty_committed:
159     case _cset:
160     case _humongous_start:
161     case _humongous_cont:
162       set_state(_regular);
163       return;
164     case _pinned_cset:
165       set_state(_pinned);
166       return;
167     case _regular:
168     case _pinned:
169       return;
170     default:
171       report_illegal_transition("regular bypass");
172   }
173 }
174 
175 void ShenandoahHeapRegion::make_humongous_start() {
176   shenandoah_assert_heaplocked();
177   reset_age();
178   switch (_state) {
179     case _empty_uncommitted:
180       do_commit();
181     case _empty_committed:
182       set_state(_humongous_start);
183       return;
184     default:
185       report_illegal_transition("humongous start allocation");
186   }
187 }
188 
189 void ShenandoahHeapRegion::make_humongous_start_bypass(ShenandoahAffiliation affiliation) {
190   shenandoah_assert_heaplocked();
191   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
192   // Don't bother to account for affiliated regions during Full GC.  We recompute totals at end.
193   set_affiliation(affiliation);
194   reset_age();
195   switch (_state) {
196     case _empty_committed:
197     case _regular:
198     case _humongous_start:
199     case _humongous_cont:
200       set_state(_humongous_start);
201       return;
202     default:
203       report_illegal_transition("humongous start bypass");
204   }
205 }
206 
207 void ShenandoahHeapRegion::make_humongous_cont() {
208   shenandoah_assert_heaplocked();
209   reset_age();
210   switch (_state) {
211     case _empty_uncommitted:
212       do_commit();
213     case _empty_committed:
214      set_state(_humongous_cont);
215       return;
216     default:
217       report_illegal_transition("humongous continuation allocation");
218   }
219 }
220 
221 void ShenandoahHeapRegion::make_humongous_cont_bypass(ShenandoahAffiliation affiliation) {
222   shenandoah_assert_heaplocked();
223   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
224   set_affiliation(affiliation);
225   // Don't bother to account for affiliated regions during Full GC.  We recompute totals at end.
226   reset_age();
227   switch (_state) {
228     case _empty_committed:
229     case _regular:
230     case _humongous_start:
231     case _humongous_cont:
232       set_state(_humongous_cont);
233       return;
234     default:
235       report_illegal_transition("humongous continuation bypass");
236   }
237 }
238 
239 void ShenandoahHeapRegion::make_pinned() {
240   shenandoah_assert_heaplocked();
241   assert(pin_count() > 0, "Should have pins: " SIZE_FORMAT, pin_count());
242 
243   switch (_state) {
244     case _regular:
245       set_state(_pinned);
246     case _pinned_cset:
247     case _pinned:
248       return;
249     case _humongous_start:
250       set_state(_pinned_humongous_start);
251     case _pinned_humongous_start:
252       return;
253     case _cset:
254       _state = _pinned_cset;
255       return;
256     default:
257       report_illegal_transition("pinning");
258   }
259 }
260 
261 void ShenandoahHeapRegion::make_unpinned() {
262   shenandoah_assert_heaplocked();
263   assert(pin_count() == 0, "Should not have pins: " SIZE_FORMAT, pin_count());
264 
265   switch (_state) {
266     case _pinned:
267       assert(is_affiliated(), "Pinned region should be affiliated");
268       set_state(_regular);
269       return;
270     case _regular:
271     case _humongous_start:
272       return;
273     case _pinned_cset:
274       set_state(_cset);
275       return;
276     case _pinned_humongous_start:
277       set_state(_humongous_start);
278       return;
279     default:
280       report_illegal_transition("unpinning");
281   }
282 }
283 
284 void ShenandoahHeapRegion::make_cset() {
285   shenandoah_assert_heaplocked();
286   // Leave age untouched.  We need to consult the age when we are deciding whether to promote evacuated objects.
287   switch (_state) {
288     case _regular:
289       set_state(_cset);
290     case _cset:
291       return;
292     default:
293       report_illegal_transition("cset");
294   }
295 }
296 
297 void ShenandoahHeapRegion::make_trash() {
298   shenandoah_assert_heaplocked();
299   reset_age();
300   switch (_state) {


301     case _humongous_start:
302     case _humongous_cont:
303     {
304       // Reclaiming humongous regions and reclaim humongous waste.  When this region is eventually recycled, we'll reclaim
305       // its used memory.  At recycle time, we no longer recognize this as a humongous region.
306       decrement_humongous_waste();
307     }
308     case _cset:
309       // Reclaiming cset regions
310     case _regular:
311       // Immediate region reclaim
312       set_state(_trash);
313       return;
314     default:
315       report_illegal_transition("trashing");
316   }
317 }
318 
319 void ShenandoahHeapRegion::make_trash_immediate() {
320   make_trash();
321 
322   // On this path, we know there are no marked objects in the region,
323   // tell marking context about it to bypass bitmap resets.
324   assert(ShenandoahHeap::heap()->active_generation()->is_mark_complete(), "Marking should be complete here.");
325   ShenandoahHeap::heap()->marking_context()->reset_top_bitmap(this);
326 }
327 
328 void ShenandoahHeapRegion::make_empty() {
329   shenandoah_assert_heaplocked();
330   reset_age();
331   CENSUS_NOISE(clear_youth();)
332   switch (_state) {
333     case _trash:
334       set_state(_empty_committed);
335       _empty_time = os::elapsedTime();
336       return;
337     default:
338       report_illegal_transition("emptying");
339   }
340 }
341 
342 void ShenandoahHeapRegion::make_uncommitted() {
343   shenandoah_assert_heaplocked();
344   switch (_state) {
345     case _empty_committed:
346       do_uncommit();
347       set_state(_empty_uncommitted);
348       return;
349     default:
350       report_illegal_transition("uncommiting");
351   }
352 }
353 
354 void ShenandoahHeapRegion::make_committed_bypass() {
355   shenandoah_assert_heaplocked();
356   assert (ShenandoahHeap::heap()->is_full_gc_in_progress(), "only for full GC");
357 
358   switch (_state) {
359     case _empty_uncommitted:
360       do_commit();
361       set_state(_empty_committed);
362       return;
363     default:
364       report_illegal_transition("commit bypass");
365   }
366 }
367 
368 void ShenandoahHeapRegion::reset_alloc_metadata() {
369   _tlab_allocs = 0;
370   _gclab_allocs = 0;
371   _plab_allocs = 0;
372 }
373 
374 size_t ShenandoahHeapRegion::get_shared_allocs() const {
375   return used() - (_tlab_allocs + _gclab_allocs + _plab_allocs) * HeapWordSize;
376 }
377 
378 size_t ShenandoahHeapRegion::get_tlab_allocs() const {
379   return _tlab_allocs * HeapWordSize;
380 }
381 
382 size_t ShenandoahHeapRegion::get_gclab_allocs() const {
383   return _gclab_allocs * HeapWordSize;
384 }
385 
386 size_t ShenandoahHeapRegion::get_plab_allocs() const {
387   return _plab_allocs * HeapWordSize;
388 }
389 
390 void ShenandoahHeapRegion::set_live_data(size_t s) {
391   assert(Thread::current()->is_VM_thread(), "by VM thread");
392   _live_data = (s >> LogHeapWordSize);
393 }
394 
395 void ShenandoahHeapRegion::print_on(outputStream* st) const {
396   st->print("|");
397   st->print(SIZE_FORMAT_W(5), this->_index);
398 
399   switch (_state) {
400     case _empty_uncommitted:
401       st->print("|EU ");
402       break;
403     case _empty_committed:
404       st->print("|EC ");
405       break;
406     case _regular:
407       st->print("|R  ");
408       break;
409     case _humongous_start:

414       break;
415     case _humongous_cont:
416       st->print("|HC ");
417       break;
418     case _cset:
419       st->print("|CS ");
420       break;
421     case _trash:
422       st->print("|TR ");
423       break;
424     case _pinned:
425       st->print("|P  ");
426       break;
427     case _pinned_cset:
428       st->print("|CSP");
429       break;
430     default:
431       ShouldNotReachHere();
432   }
433 
434   st->print("|%s", shenandoah_affiliation_code(affiliation()));
435 
436 #define SHR_PTR_FORMAT "%12" PRIxPTR
437 
438   st->print("|BTE " SHR_PTR_FORMAT  ", " SHR_PTR_FORMAT ", " SHR_PTR_FORMAT,
439             p2i(bottom()), p2i(top()), p2i(end()));
440   st->print("|TAMS " SHR_PTR_FORMAT,
441             p2i(ShenandoahHeap::heap()->marking_context()->top_at_mark_start(const_cast<ShenandoahHeapRegion*>(this))));
442   st->print("|UWM " SHR_PTR_FORMAT,
443             p2i(_update_watermark));
444   st->print("|U " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(used()),                proper_unit_for_byte_size(used()));
445   st->print("|T " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_tlab_allocs()),     proper_unit_for_byte_size(get_tlab_allocs()));
446   st->print("|G " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_gclab_allocs()),    proper_unit_for_byte_size(get_gclab_allocs()));
447   if (ShenandoahHeap::heap()->mode()->is_generational()) {
448     st->print("|P " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_plab_allocs()),   proper_unit_for_byte_size(get_plab_allocs()));
449   }
450   st->print("|S " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_shared_allocs()),   proper_unit_for_byte_size(get_shared_allocs()));
451   st->print("|L " SIZE_FORMAT_W(5) "%1s", byte_size_in_proper_unit(get_live_data_bytes()), proper_unit_for_byte_size(get_live_data_bytes()));
452   st->print("|CP " SIZE_FORMAT_W(3), pin_count());
453   st->cr();
454 
455 #undef SHR_PTR_FORMAT
456 }
457 
458 // oop_iterate without closure, return true if completed without cancellation
459 bool ShenandoahHeapRegion::oop_coalesce_and_fill(bool cancellable) {
460 
461   // Consider yielding to cancel/preemption request after this many coalesce operations (skip marked, or coalesce free).
462   const size_t preemption_stride = 128;
463 
464   assert(!is_humongous(), "No need to fill or coalesce humongous regions");
465   if (!is_active()) {
466     end_preemptible_coalesce_and_fill();
467     return true;
468   }

469 
470   ShenandoahGenerationalHeap* heap = ShenandoahGenerationalHeap::heap();
471   ShenandoahMarkingContext* marking_context = heap->marking_context();
472 
473   // Expect marking to be completed before these threads invoke this service.
474   assert(heap->active_generation()->is_mark_complete(), "sanity");
475 
476   // All objects above TAMS are considered live even though their mark bits will not be set.  Note that young-
477   // gen evacuations that interrupt a long-running old-gen concurrent mark may promote objects into old-gen
478   // while the old-gen concurrent marking is ongoing.  These newly promoted objects will reside above TAMS
479   // and will be treated as live during the current old-gen marking pass, even though they will not be
480   // explicitly marked.
481   HeapWord* t = marking_context->top_at_mark_start(this);
482 
483   // Resume coalesce and fill from this address
484   HeapWord* obj_addr = resume_coalesce_and_fill();
485 
486   size_t ops_before_preempt_check = preemption_stride;
487   while (obj_addr < t) {
488     oop obj = cast_to_oop(obj_addr);
489     if (marking_context->is_marked(obj)) {
490       assert(obj->klass() != nullptr, "klass should not be nullptr");
491       obj_addr += obj->size();
492     } else {
493       // Object is not marked.  Coalesce and fill dead object with dead neighbors.
494       HeapWord* next_marked_obj = marking_context->get_next_marked_addr(obj_addr, t);
495       assert(next_marked_obj <= t, "next marked object cannot exceed top");
496       size_t fill_size = next_marked_obj - obj_addr;
497       assert(fill_size >= ShenandoahHeap::min_fill_size(), "previously allocated object known to be larger than min_size");
498       ShenandoahHeap::fill_with_object(obj_addr, fill_size);
499       heap->old_generation()->card_scan()->coalesce_objects(obj_addr, fill_size);
500       obj_addr = next_marked_obj;
501     }
502     if (cancellable && ops_before_preempt_check-- == 0) {
503       if (heap->cancelled_gc()) {
504         suspend_coalesce_and_fill(obj_addr);
505         return false;
506       }
507       ops_before_preempt_check = preemption_stride;
508     }
509   }
510   // Mark that this region has been coalesced and filled
511   end_preemptible_coalesce_and_fill();
512   return true;
513 }
514 
515 // DO NOT CANCEL.  If this worker thread has accepted responsibility for scanning a particular range of addresses, it
516 // must finish the work before it can be cancelled.
517 void ShenandoahHeapRegion::oop_iterate_humongous_slice(OopIterateClosure* blk, bool dirty_only,
518                                                        HeapWord* start, size_t words, bool write_table) {
519   assert(words % CardTable::card_size_in_words() == 0, "Humongous iteration must span whole number of cards");
520   assert(is_humongous(), "only humongous region here");
521   ShenandoahGenerationalHeap* heap = ShenandoahGenerationalHeap::heap();
522 
523   // Find head.
524   ShenandoahHeapRegion* r = humongous_start_region();
525   assert(r->is_humongous_start(), "need humongous head here");
526   assert(CardTable::card_size_in_words() * (words / CardTable::card_size_in_words()) == words,
527          "slice must be integral number of cards");
528 
529   oop obj = cast_to_oop(r->bottom());
530   RememberedScanner* scanner = heap->old_generation()->card_scan();
531   size_t card_index = scanner->card_index_for_addr(start);
532   size_t num_cards = words / CardTable::card_size_in_words();
533 
534   if (dirty_only) {
535     if (write_table) {
536       while (num_cards-- > 0) {
537         if (scanner->is_write_card_dirty(card_index++)) {
538           obj->oop_iterate(blk, MemRegion(start, start + CardTable::card_size_in_words()));
539         }
540         start += CardTable::card_size_in_words();
541       }
542     } else {
543       while (num_cards-- > 0) {
544         if (scanner->is_card_dirty(card_index++)) {
545           obj->oop_iterate(blk, MemRegion(start, start + CardTable::card_size_in_words()));
546         }
547         start += CardTable::card_size_in_words();
548       }
549     }
550   } else {
551     // Scan all data, regardless of whether cards are dirty
552     obj->oop_iterate(blk, MemRegion(start, start + num_cards * CardTable::card_size_in_words()));
553   }
554 }
555 
556 ShenandoahHeapRegion* ShenandoahHeapRegion::humongous_start_region() const {
557   ShenandoahHeap* heap = ShenandoahHeap::heap();
558   assert(is_humongous(), "Must be a part of the humongous region");
559   size_t i = index();
560   ShenandoahHeapRegion* r = const_cast<ShenandoahHeapRegion*>(this);
561   while (!r->is_humongous_start()) {
562     assert(i > 0, "Sanity");
563     i--;
564     r = heap->get_region(i);
565     assert(r->is_humongous(), "Must be a part of the humongous region");
566   }
567   assert(r->is_humongous_start(), "Must be");
568   return r;
569 }
570 
571 void ShenandoahHeapRegion::recycle() {
572   shenandoah_assert_heaplocked();
573   ShenandoahHeap* heap = ShenandoahHeap::heap();
574   ShenandoahGeneration* generation = heap->generation_for(affiliation());
575 
576   heap->decrease_used(generation, used());
577   generation->decrement_affiliated_region_count();
578 
579   set_top(bottom());
580   clear_live_data();
581 
582   reset_alloc_metadata();
583 
584   heap->marking_context()->reset_top_at_mark_start(this);
585   set_update_watermark(bottom());
586 
587   make_empty();
588 
589   set_affiliation(FREE);
590   if (ZapUnusedHeapArea) {
591     SpaceMangler::mangle_region(MemRegion(bottom(), end()));
592   }
593 }
594 
595 HeapWord* ShenandoahHeapRegion::block_start(const void* p) const {
596   assert(MemRegion(bottom(), end()).contains(p),
597          "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
598          p2i(p), p2i(bottom()), p2i(end()));
599   if (p >= top()) {
600     return top();
601   } else {
602     HeapWord* last = bottom();
603     HeapWord* cur = last;
604     while (cur <= p) {
605       last = cur;
606       cur += cast_to_oop(cur)->size();
607     }
608     shenandoah_assert_correct(nullptr, cast_to_oop(last));
609     return last;

613 size_t ShenandoahHeapRegion::block_size(const HeapWord* p) const {
614   assert(MemRegion(bottom(), end()).contains(p),
615          "p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
616          p2i(p), p2i(bottom()), p2i(end()));
617   if (p < top()) {
618     return cast_to_oop(p)->size();
619   } else {
620     assert(p == top(), "just checking");
621     return pointer_delta(end(), (HeapWord*) p);
622   }
623 }
624 
625 size_t ShenandoahHeapRegion::setup_sizes(size_t max_heap_size) {
626   // Absolute minimums we should not ever break.
627   static const size_t MIN_REGION_SIZE = 256*K;
628 
629   if (FLAG_IS_DEFAULT(ShenandoahMinRegionSize)) {
630     FLAG_SET_DEFAULT(ShenandoahMinRegionSize, MIN_REGION_SIZE);
631   }
632 
633   // Generational Shenandoah needs this alignment for card tables.
634   if (strcmp(ShenandoahGCMode, "generational") == 0) {
635     max_heap_size = align_up(max_heap_size , CardTable::ct_max_alignment_constraint());
636   }
637 
638   size_t region_size;
639   if (FLAG_IS_DEFAULT(ShenandoahRegionSize)) {
640     if (ShenandoahMinRegionSize > max_heap_size / MIN_NUM_REGIONS) {
641       err_msg message("Max heap size (" SIZE_FORMAT "%s) is too low to afford the minimum number "
642                       "of regions (" SIZE_FORMAT ") of minimum region size (" SIZE_FORMAT "%s).",
643                       byte_size_in_proper_unit(max_heap_size), proper_unit_for_byte_size(max_heap_size),
644                       MIN_NUM_REGIONS,
645                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize));
646       vm_exit_during_initialization("Invalid -XX:ShenandoahMinRegionSize option", message);
647     }
648     if (ShenandoahMinRegionSize < MIN_REGION_SIZE) {
649       err_msg message("" SIZE_FORMAT "%s should not be lower than minimum region size (" SIZE_FORMAT "%s).",
650                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize),
651                       byte_size_in_proper_unit(MIN_REGION_SIZE),         proper_unit_for_byte_size(MIN_REGION_SIZE));
652       vm_exit_during_initialization("Invalid -XX:ShenandoahMinRegionSize option", message);
653     }
654     if (ShenandoahMinRegionSize < MinTLABSize) {
655       err_msg message("" SIZE_FORMAT "%s should not be lower than TLAB size size (" SIZE_FORMAT "%s).",
656                       byte_size_in_proper_unit(ShenandoahMinRegionSize), proper_unit_for_byte_size(ShenandoahMinRegionSize),
657                       byte_size_in_proper_unit(MinTLABSize),             proper_unit_for_byte_size(MinTLABSize));

806     evt.set_used(used());
807     evt.set_from(_state);
808     evt.set_to(to);
809     evt.commit();
810   }
811   _state = to;
812 }
813 
814 void ShenandoahHeapRegion::record_pin() {
815   Atomic::add(&_critical_pins, (size_t)1);
816 }
817 
818 void ShenandoahHeapRegion::record_unpin() {
819   assert(pin_count() > 0, "Region " SIZE_FORMAT " should have non-zero pins", index());
820   Atomic::sub(&_critical_pins, (size_t)1);
821 }
822 
823 size_t ShenandoahHeapRegion::pin_count() const {
824   return Atomic::load(&_critical_pins);
825 }
826 
827 void ShenandoahHeapRegion::set_affiliation(ShenandoahAffiliation new_affiliation) {
828   ShenandoahHeap* heap = ShenandoahHeap::heap();
829 
830   ShenandoahAffiliation region_affiliation = heap->region_affiliation(this);
831   {
832     ShenandoahMarkingContext* const ctx = heap->complete_marking_context();
833     log_debug(gc)("Setting affiliation of Region " SIZE_FORMAT " from %s to %s, top: " PTR_FORMAT ", TAMS: " PTR_FORMAT
834                   ", watermark: " PTR_FORMAT ", top_bitmap: " PTR_FORMAT,
835                   index(), shenandoah_affiliation_name(region_affiliation), shenandoah_affiliation_name(new_affiliation),
836                   p2i(top()), p2i(ctx->top_at_mark_start(this)), p2i(_update_watermark), p2i(ctx->top_bitmap(this)));
837   }
838 
839 #ifdef ASSERT
840   {
841     // During full gc, heap->complete_marking_context() is not valid, may equal nullptr.
842     ShenandoahMarkingContext* const ctx = heap->complete_marking_context();
843     size_t idx = this->index();
844     HeapWord* top_bitmap = ctx->top_bitmap(this);
845 
846     assert(ctx->is_bitmap_clear_range(top_bitmap, _end),
847            "Region " SIZE_FORMAT ", bitmap should be clear between top_bitmap: " PTR_FORMAT " and end: " PTR_FORMAT, idx,
848            p2i(top_bitmap), p2i(_end));
849   }
850 #endif
851 
852   if (region_affiliation == new_affiliation) {
853     return;
854   }
855 
856   if (!heap->mode()->is_generational()) {
857     log_trace(gc)("Changing affiliation of region %zu from %s to %s",
858                   index(), affiliation_name(), shenandoah_affiliation_name(new_affiliation));
859     heap->set_affiliation(this, new_affiliation);
860     return;
861   }
862 
863   switch (new_affiliation) {
864     case FREE:
865       assert(!has_live(), "Free region should not have live data");
866       break;
867     case YOUNG_GENERATION:
868       reset_age();
869       break;
870     case OLD_GENERATION:
871       // TODO: should we reset_age() for OLD as well?  Examine invocations of set_affiliation(). Some contexts redundantly
872       //       invoke reset_age().
873       break;
874     default:
875       ShouldNotReachHere();
876       return;
877   }
878   heap->set_affiliation(this, new_affiliation);
879 }
880 
881 void ShenandoahHeapRegion::decrement_humongous_waste() const {
882   assert(is_humongous(), "Should only use this for humongous regions");
883   size_t waste_bytes = free();
884   if (waste_bytes > 0) {
885     ShenandoahHeap* heap = ShenandoahHeap::heap();
886     ShenandoahGeneration* generation = heap->generation_for(affiliation());
887     heap->decrease_humongous_waste(generation, waste_bytes);
888   }
889 }
< prev index next >