< prev index next >

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

Print this page

  1 /*
  2  * Copyright (c) 2013, 2019, Red Hat, Inc. 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 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP
 26 #define SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP
 27 
 28 #include "gc/shared/gc_globals.hpp"
 29 #include "gc/shared/spaceDecorator.hpp"

 30 #include "gc/shenandoah/shenandoahAllocRequest.hpp"
 31 #include "gc/shenandoah/shenandoahAsserts.hpp"
 32 #include "gc/shenandoah/shenandoahHeap.hpp"
 33 #include "gc/shenandoah/shenandoahPacer.hpp"
 34 #include "gc/shenandoah/shenandoahPadding.hpp"
 35 #include "utilities/sizes.hpp"
 36 
 37 class VMStructs;
 38 class ShenandoahHeapRegionStateConstant;
 39 
 40 class ShenandoahHeapRegion {
 41   friend class VMStructs;
 42   friend class ShenandoahHeapRegionStateConstant;
 43 private:
 44   /*
 45     Region state is described by a state machine. Transitions are guarded by
 46     heap lock, which allows changing the state of several regions atomically.
 47     Region states can be logically aggregated in groups.
 48 
 49       "Empty":

146     switch (s) {
147       case _empty_uncommitted:      return 0;
148       case _empty_committed:        return 1;
149       case _regular:                return 2;
150       case _humongous_start:        return 3;
151       case _humongous_cont:         return 4;
152       case _cset:                   return 5;
153       case _pinned:                 return 6;
154       case _trash:                  return 7;
155       case _pinned_cset:            return 8;
156       case _pinned_humongous_start: return 9;
157       default:
158         ShouldNotReachHere();
159         return -1;
160     }
161   }
162 
163   void report_illegal_transition(const char* method);
164 
165 public:
166   static const int region_states_num() {
167     return _REGION_STATES_NUM;
168   }
169 
170   // Allowed transitions from the outside code:
171   void make_regular_allocation();

172   void make_regular_bypass();
173   void make_humongous_start();
174   void make_humongous_cont();
175   void make_humongous_start_bypass();
176   void make_humongous_cont_bypass();
177   void make_pinned();
178   void make_unpinned();
179   void make_cset();
180   void make_trash();
181   void make_trash_immediate();
182   void make_empty();
183   void make_uncommitted();
184   void make_committed_bypass();
185 
186   // Individual states:
187   bool is_empty_uncommitted()      const { return _state == _empty_uncommitted; }
188   bool is_empty_committed()        const { return _state == _empty_committed; }
189   bool is_regular()                const { return _state == _regular; }
190   bool is_humongous_continuation() const { return _state == _humongous_cont; }
191 
192   // Participation in logical groups:
193   bool is_empty()                  const { return is_empty_committed() || is_empty_uncommitted(); }
194   bool is_active()                 const { return !is_empty() && !is_trash(); }
195   bool is_trash()                  const { return _state == _trash; }
196   bool is_humongous_start()        const { return _state == _humongous_start || _state == _pinned_humongous_start; }
197   bool is_humongous()              const { return is_humongous_start() || is_humongous_continuation(); }
198   bool is_committed()              const { return !is_empty_uncommitted(); }
199   bool is_cset()                   const { return _state == _cset   || _state == _pinned_cset; }
200   bool is_pinned()                 const { return _state == _pinned || _state == _pinned_cset || _state == _pinned_humongous_start; }



201 
202   // Macro-properties:
203   bool is_alloc_allowed()          const { return is_empty() || is_regular() || _state == _pinned; }
204   bool is_stw_move_allowed()       const { return is_regular() || _state == _cset || (ShenandoahHumongousMoves && _state == _humongous_start); }
205 
206   RegionState state()              const { return _state; }
207   int  state_ordinal()             const { return region_state_to_ordinal(_state); }
208 
209   void record_pin();
210   void record_unpin();
211   size_t pin_count() const;
212 
213 private:
214   static size_t RegionCount;
215   static size_t RegionSizeBytes;
216   static size_t RegionSizeWords;
217   static size_t RegionSizeBytesShift;
218   static size_t RegionSizeWordsShift;
219   static size_t RegionSizeBytesMask;
220   static size_t RegionSizeWordsMask;
221   static size_t HumongousThresholdBytes;
222   static size_t HumongousThresholdWords;
223   static size_t MaxTLABSizeBytes;
224   static size_t MaxTLABSizeWords;
225 
226   // Never updated fields
227   size_t const _index;
228   HeapWord* const _bottom;
229   HeapWord* const _end;
230 
231   // Rarely updated fields
232   HeapWord* _new_top;
233   double _empty_time;
234 


235   // Seldom updated fields
236   RegionState _state;

237 
238   // Frequently updated fields
239   HeapWord* _top;
240 
241   size_t _tlab_allocs;
242   size_t _gclab_allocs;

243 
244   volatile size_t _live_data;
245   volatile size_t _critical_pins;
246 
247   HeapWord* volatile _update_watermark;
248 



249 public:
250   ShenandoahHeapRegion(HeapWord* start, size_t index, bool committed);
251 
252   static const size_t MIN_NUM_REGIONS = 10;
253 
254   // Return adjusted max heap size
255   static size_t setup_sizes(size_t max_heap_size);
256 
257   double empty_time() {
258     return _empty_time;
259   }
260 
261   inline static size_t required_regions(size_t bytes) {
262     return (bytes + ShenandoahHeapRegion::region_size_bytes() - 1) >> ShenandoahHeapRegion::region_size_bytes_shift();
263   }
264 
265   inline static size_t region_count() {
266     return ShenandoahHeapRegion::RegionCount;
267   }
268 

317   inline static size_t humongous_threshold_bytes() {
318     return ShenandoahHeapRegion::HumongousThresholdBytes;
319   }
320 
321   inline static size_t humongous_threshold_words() {
322     return ShenandoahHeapRegion::HumongousThresholdWords;
323   }
324 
325   inline static size_t max_tlab_size_bytes() {
326     return ShenandoahHeapRegion::MaxTLABSizeBytes;
327   }
328 
329   inline static size_t max_tlab_size_words() {
330     return ShenandoahHeapRegion::MaxTLABSizeWords;
331   }
332 
333   inline size_t index() const {
334     return _index;
335   }
336 
337   // Allocation (return null if full)
338   inline HeapWord* allocate(size_t word_size, ShenandoahAllocRequest::Type type);








339 
340   inline void clear_live_data();
341   void set_live_data(size_t s);
342 
343   // Increase live data for newly allocated region
344   inline void increase_live_data_alloc_words(size_t s);
345 
346   // Increase live data for region scanned with GC
347   inline void increase_live_data_gc_words(size_t s);
348 
349   inline bool has_live() const;
350   inline size_t get_live_data_bytes() const;
351   inline size_t get_live_data_words() const;
352 
353   inline size_t garbage() const;
354 
355   void print_on(outputStream* st) const;
356 
357   void recycle();
358 
359   void oop_iterate(OopIterateClosure* cl);


































360 
361   HeapWord* block_start(const void* p) const;
362   size_t block_size(const HeapWord* p) const;
363   bool block_is_obj(const HeapWord* p) const { return p < top(); }
364 
365   // Find humongous start region that this region belongs to
366   ShenandoahHeapRegion* humongous_start_region() const;
367 
368   HeapWord* top() const         { return _top;     }
369   void set_top(HeapWord* v)     { _top = v;        }
370 
371   HeapWord* new_top() const     { return _new_top; }
372   void set_new_top(HeapWord* v) { _new_top = v;    }
373 
374   HeapWord* bottom() const      { return _bottom;  }
375   HeapWord* end() const         { return _end;     }
376 
377   size_t capacity() const       { return byte_size(bottom(), end()); }
378   size_t used() const           { return byte_size(bottom(), top()); }

379   size_t free() const           { return byte_size(top(),    end()); }
380 





381   inline void adjust_alloc_metadata(ShenandoahAllocRequest::Type type, size_t);
382   void reset_alloc_metadata();
383   size_t get_shared_allocs() const;
384   size_t get_tlab_allocs() const;
385   size_t get_gclab_allocs() const;

386 
387   inline HeapWord* get_update_watermark() const;
388   inline void set_update_watermark(HeapWord* w);
389   inline void set_update_watermark_at_safepoint(HeapWord* w);
390 




























391 private:

392   void do_commit();
393   void do_uncommit();
394 
395   void oop_iterate_objects(OopIterateClosure* cl);
396   void oop_iterate_humongous(OopIterateClosure* cl);

397 
398   inline void internal_increase_live_data(size_t s);
399 
400   void set_state(RegionState to);
401 };
402 
403 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP

  1 /*
  2  * Copyright (c) 2013, 2019, Red Hat, Inc. All rights reserved.
  3  * Copyright Amazon.com Inc. or its affiliates. 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 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP
 27 #define SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP
 28 
 29 #include "gc/shared/gc_globals.hpp"
 30 #include "gc/shared/spaceDecorator.hpp"
 31 #include "gc/shenandoah/shenandoahAffiliation.hpp"
 32 #include "gc/shenandoah/shenandoahAllocRequest.hpp"
 33 #include "gc/shenandoah/shenandoahAsserts.hpp"
 34 #include "gc/shenandoah/shenandoahHeap.hpp"
 35 #include "gc/shenandoah/shenandoahPacer.hpp"
 36 #include "gc/shenandoah/shenandoahPadding.hpp"
 37 #include "utilities/sizes.hpp"
 38 
 39 class VMStructs;
 40 class ShenandoahHeapRegionStateConstant;
 41 
 42 class ShenandoahHeapRegion {
 43   friend class VMStructs;
 44   friend class ShenandoahHeapRegionStateConstant;
 45 private:
 46   /*
 47     Region state is described by a state machine. Transitions are guarded by
 48     heap lock, which allows changing the state of several regions atomically.
 49     Region states can be logically aggregated in groups.
 50 
 51       "Empty":

148     switch (s) {
149       case _empty_uncommitted:      return 0;
150       case _empty_committed:        return 1;
151       case _regular:                return 2;
152       case _humongous_start:        return 3;
153       case _humongous_cont:         return 4;
154       case _cset:                   return 5;
155       case _pinned:                 return 6;
156       case _trash:                  return 7;
157       case _pinned_cset:            return 8;
158       case _pinned_humongous_start: return 9;
159       default:
160         ShouldNotReachHere();
161         return -1;
162     }
163   }
164 
165   void report_illegal_transition(const char* method);
166 
167 public:
168   static int region_states_num() {
169     return _REGION_STATES_NUM;
170   }
171 
172   // Allowed transitions from the outside code:
173   void make_regular_allocation(ShenandoahAffiliation affiliation);
174   void make_young_maybe();
175   void make_regular_bypass();
176   void make_humongous_start();
177   void make_humongous_cont();
178   void make_humongous_start_bypass(ShenandoahAffiliation affiliation);
179   void make_humongous_cont_bypass(ShenandoahAffiliation affiliation);
180   void make_pinned();
181   void make_unpinned();
182   void make_cset();
183   void make_trash();
184   void make_trash_immediate();
185   void make_empty();
186   void make_uncommitted();
187   void make_committed_bypass();
188 
189   // Individual states:
190   bool is_empty_uncommitted()      const { return _state == _empty_uncommitted; }
191   bool is_empty_committed()        const { return _state == _empty_committed; }
192   bool is_regular()                const { return _state == _regular; }
193   bool is_humongous_continuation() const { return _state == _humongous_cont; }
194 
195   // Participation in logical groups:
196   bool is_empty()                  const { return is_empty_committed() || is_empty_uncommitted(); }
197   bool is_active()                 const { return !is_empty() && !is_trash(); }
198   bool is_trash()                  const { return _state == _trash; }
199   bool is_humongous_start()        const { return _state == _humongous_start || _state == _pinned_humongous_start; }
200   bool is_humongous()              const { return is_humongous_start() || is_humongous_continuation(); }
201   bool is_committed()              const { return !is_empty_uncommitted(); }
202   bool is_cset()                   const { return _state == _cset   || _state == _pinned_cset; }
203   bool is_pinned()                 const { return _state == _pinned || _state == _pinned_cset || _state == _pinned_humongous_start; }
204   inline bool is_young() const;
205   inline bool is_old() const;
206   inline bool is_affiliated() const;
207 
208   // Macro-properties:
209   bool is_alloc_allowed()          const { return is_empty() || is_regular() || _state == _pinned; }
210   bool is_stw_move_allowed()       const { return is_regular() || _state == _cset || (ShenandoahHumongousMoves && _state == _humongous_start); }
211 
212   RegionState state()              const { return _state; }
213   int  state_ordinal()             const { return region_state_to_ordinal(_state); }
214 
215   void record_pin();
216   void record_unpin();
217   size_t pin_count() const;
218 
219 private:
220   static size_t RegionCount;
221   static size_t RegionSizeBytes;
222   static size_t RegionSizeWords;
223   static size_t RegionSizeBytesShift;
224   static size_t RegionSizeWordsShift;
225   static size_t RegionSizeBytesMask;
226   static size_t RegionSizeWordsMask;
227   static size_t HumongousThresholdBytes;
228   static size_t HumongousThresholdWords;
229   static size_t MaxTLABSizeBytes;
230   static size_t MaxTLABSizeWords;
231 
232   // Never updated fields
233   size_t const _index;
234   HeapWord* const _bottom;
235   HeapWord* const _end;
236 
237   // Rarely updated fields
238   HeapWord* _new_top;
239   double _empty_time;
240 
241   HeapWord* _top_before_promoted;
242 
243   // Seldom updated fields
244   RegionState _state;
245   HeapWord* _coalesce_and_fill_boundary; // for old regions not selected as collection set candidates.
246 
247   // Frequently updated fields
248   HeapWord* _top;
249 
250   size_t _tlab_allocs;
251   size_t _gclab_allocs;
252   size_t _plab_allocs;
253 
254   volatile size_t _live_data;
255   volatile size_t _critical_pins;
256 
257   HeapWord* volatile _update_watermark;
258 
259   uint _age;
260   CENSUS_NOISE(uint _youth;)   // tracks epochs of retrograde ageing (rejuvenation)
261 
262 public:
263   ShenandoahHeapRegion(HeapWord* start, size_t index, bool committed);
264 
265   static const size_t MIN_NUM_REGIONS = 10;
266 
267   // Return adjusted max heap size
268   static size_t setup_sizes(size_t max_heap_size);
269 
270   double empty_time() {
271     return _empty_time;
272   }
273 
274   inline static size_t required_regions(size_t bytes) {
275     return (bytes + ShenandoahHeapRegion::region_size_bytes() - 1) >> ShenandoahHeapRegion::region_size_bytes_shift();
276   }
277 
278   inline static size_t region_count() {
279     return ShenandoahHeapRegion::RegionCount;
280   }
281 

330   inline static size_t humongous_threshold_bytes() {
331     return ShenandoahHeapRegion::HumongousThresholdBytes;
332   }
333 
334   inline static size_t humongous_threshold_words() {
335     return ShenandoahHeapRegion::HumongousThresholdWords;
336   }
337 
338   inline static size_t max_tlab_size_bytes() {
339     return ShenandoahHeapRegion::MaxTLABSizeBytes;
340   }
341 
342   inline static size_t max_tlab_size_words() {
343     return ShenandoahHeapRegion::MaxTLABSizeWords;
344   }
345 
346   inline size_t index() const {
347     return _index;
348   }
349 
350   inline void save_top_before_promote();
351   inline HeapWord* get_top_before_promote() const { return _top_before_promoted; }
352   inline void restore_top_before_promote();
353   inline size_t garbage_before_padded_for_promote() const;
354 
355   // Allocation (return nullptr if full)
356   inline HeapWord* allocate_aligned(size_t word_size, ShenandoahAllocRequest &req, size_t alignment_in_words);
357 
358   // Allocation (return nullptr if full)
359   inline HeapWord* allocate(size_t word_size, ShenandoahAllocRequest req);
360 
361   inline void clear_live_data();
362   void set_live_data(size_t s);
363 
364   // Increase live data for newly allocated region
365   inline void increase_live_data_alloc_words(size_t s);
366 
367   // Increase live data for region scanned with GC
368   inline void increase_live_data_gc_words(size_t s);
369 
370   inline bool has_live() const;
371   inline size_t get_live_data_bytes() const;
372   inline size_t get_live_data_words() const;
373 
374   inline size_t garbage() const;
375 
376   void print_on(outputStream* st) const;
377 
378   void recycle();
379 
380   inline void begin_preemptible_coalesce_and_fill() {
381     _coalesce_and_fill_boundary = _bottom;
382   }
383 
384   inline void end_preemptible_coalesce_and_fill() {
385     _coalesce_and_fill_boundary = _end;
386   }
387 
388   inline void suspend_coalesce_and_fill(HeapWord* next_focus) {
389     _coalesce_and_fill_boundary = next_focus;
390   }
391 
392   inline HeapWord* resume_coalesce_and_fill() {
393     return _coalesce_and_fill_boundary;
394   }
395 
396   // Coalesce contiguous spans of garbage objects by filling header and reregistering start locations with remembered set.
397   // This is used by old-gen GC following concurrent marking to make old-gen HeapRegions parsable.  Return true iff
398   // region is completely coalesced and filled.  Returns false if cancelled before task is complete.
399   bool oop_fill_and_coalesce();
400 
401   // Like oop_fill_and_coalesce(), but without honoring cancellation requests.
402   bool oop_fill_and_coalesce_without_cancel();
403 
404   // During global collections, this service iterates through an old-gen heap region that is not part of collection
405   // set to fill and register ranges of dead memory.  Note that live objects were previously registered.  Some dead objects
406   // that are subsumed into coalesced ranges of dead memory need to be "unregistered".
407   void global_oop_iterate_and_fill_dead(OopIterateClosure* cl);
408   void oop_iterate_humongous(OopIterateClosure* cl);
409   void oop_iterate_humongous(OopIterateClosure* cl, HeapWord* start, size_t words);
410 
411   // Invoke closure on every reference contained within the humongous object that spans this humongous
412   // region if the reference is contained within a DIRTY card and the reference is no more than words following
413   // start within the humongous object.
414   void oop_iterate_humongous_slice(OopIterateClosure* cl, bool dirty_only, HeapWord* start, size_t words, bool write_table);
415 
416   HeapWord* block_start(const void* p) const;
417   size_t block_size(const HeapWord* p) const;
418   bool block_is_obj(const HeapWord* p) const { return p < top(); }
419 
420   // Find humongous start region that this region belongs to
421   ShenandoahHeapRegion* humongous_start_region() const;
422 
423   HeapWord* top() const         { return _top;     }
424   void set_top(HeapWord* v)     { _top = v;        }
425 
426   HeapWord* new_top() const     { return _new_top; }
427   void set_new_top(HeapWord* v) { _new_top = v;    }
428 
429   HeapWord* bottom() const      { return _bottom;  }
430   HeapWord* end() const         { return _end;     }
431 
432   size_t capacity() const       { return byte_size(bottom(), end()); }
433   size_t used() const           { return byte_size(bottom(), top()); }
434   size_t used_before_promote() const { return byte_size(bottom(), get_top_before_promote()); }
435   size_t free() const           { return byte_size(top(),    end()); }
436 
437   // Does this region contain this address?
438   bool contains(HeapWord* p) const {
439     return (bottom() <= p) && (p < top());
440   }
441 
442   inline void adjust_alloc_metadata(ShenandoahAllocRequest::Type type, size_t);
443   void reset_alloc_metadata();
444   size_t get_shared_allocs() const;
445   size_t get_tlab_allocs() const;
446   size_t get_gclab_allocs() const;
447   size_t get_plab_allocs() const;
448 
449   inline HeapWord* get_update_watermark() const;
450   inline void set_update_watermark(HeapWord* w);
451   inline void set_update_watermark_at_safepoint(HeapWord* w);
452 
453   inline ShenandoahAffiliation affiliation() const;
454   inline const char* affiliation_name() const;
455 
456   void set_affiliation(ShenandoahAffiliation new_affiliation);
457 
458   // Region ageing and rejuvenation
459   uint age() { return _age; }
460   CENSUS_NOISE(uint youth() { return _youth; })
461 
462   void increment_age() {
463     const uint max_age = markWord::max_age;
464     assert(_age <= max_age, "Error");
465     if (_age++ >= max_age) {
466       _age = max_age;   // clamp
467     }
468   }
469 
470   void reset_age() {
471     CENSUS_NOISE(_youth += _age;)
472     _age = 0;
473   }
474 
475   CENSUS_NOISE(void clear_youth() { _youth = 0; })
476 
477   // Register all objects.  Set all remembered set cards to dirty.
478   void promote_humongous();
479   void promote_in_place();
480 
481 private:
482   void decrement_humongous_waste() const;
483   void do_commit();
484   void do_uncommit();
485 
486   // This is an old-region that was not part of the collection set during a GLOBAL collection.  We coalesce the dead
487   // objects, but do not need to register the live objects as they are already registered.
488   void global_oop_iterate_objects_and_fill_dead(OopIterateClosure* cl);
489 
490   inline void internal_increase_live_data(size_t s);
491 
492   void set_state(RegionState to);
493 };
494 
495 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHHEAPREGION_HPP
< prev index next >