< prev index next >

src/hotspot/share/gc/g1/heapRegion.hpp

Print this page
rev 52676 : imported patch AMGC-impl
rev 52677 : imported patch AMGC-tsch-rev1


 233   HeapRegion* _humongous_start_region;
 234 
 235   // True iff an attempt to evacuate an object in the region failed.
 236   bool _evacuation_failed;
 237 
 238   // Fields used by the HeapRegionSetBase class and subclasses.
 239   HeapRegion* _next;
 240   HeapRegion* _prev;
 241 #ifdef ASSERT
 242   HeapRegionSetBase* _containing_set;
 243 #endif // ASSERT
 244 
 245   // We use concurrent marking to determine the amount of live data
 246   // in each heap region.
 247   size_t _prev_marked_bytes;    // Bytes known to be live via last completed marking.
 248   size_t _next_marked_bytes;    // Bytes known to be live via in-progress marking.
 249 
 250   // The calculated GC efficiency of the region.
 251   double _gc_efficiency;
 252 



 253   int  _young_index_in_cset;
 254   SurvRateGroup* _surv_rate_group;
 255   int  _age_index;
 256 
 257   // The start of the unmarked area. The unmarked area extends from this
 258   // word until the top and/or end of the region, and is the part
 259   // of the region for which no marking was done, i.e. objects may
 260   // have been allocated in this part since the last mark phase.
 261   // "prev" is the top at the start of the last completed marking.
 262   // "next" is the top at the start of the in-progress marking (if any.)
 263   HeapWord* _prev_top_at_mark_start;
 264   HeapWord* _next_top_at_mark_start;
 265   // If a collection pause is in progress, this is the top at the start
 266   // of that pause.
 267 
 268   void init_top_at_mark_start() {
 269     assert(_prev_marked_bytes == 0 &&
 270            _next_marked_bytes == 0,
 271            "Must be called after zero_marked_bytes.");
 272     HeapWord* bot = bottom();


 536 
 537   // Notify the region that we are about to start processing
 538   // self-forwarded objects during evac failure handling.
 539   void note_self_forwarding_removal_start(bool during_initial_mark,
 540                                           bool during_conc_mark);
 541 
 542   // Notify the region that we have finished processing self-forwarded
 543   // objects during evac failure handling.
 544   void note_self_forwarding_removal_end(size_t marked_bytes);
 545 
 546   void reset_during_compaction() {
 547     assert(is_humongous(),
 548            "should only be called for humongous regions");
 549 
 550     zero_marked_bytes();
 551     init_top_at_mark_start();
 552   }
 553 
 554   void calc_gc_efficiency(void);
 555   double gc_efficiency() { return _gc_efficiency;}



 556 
 557   int  young_index_in_cset() const { return _young_index_in_cset; }
 558   void set_young_index_in_cset(int index) {
 559     assert( (index == -1) || is_young(), "pre-condition" );
 560     _young_index_in_cset = index;
 561   }
 562 
 563   int age_in_surv_rate_group() {
 564     assert( _surv_rate_group != NULL, "pre-condition" );
 565     assert( _age_index > -1, "pre-condition" );
 566     return _surv_rate_group->age_in_group(_age_index);
 567   }
 568 
 569   void record_surv_words_in_group(size_t words_survived) {
 570     assert( _surv_rate_group != NULL, "pre-condition" );
 571     assert( _age_index > -1, "pre-condition" );
 572     int age_in_group = age_in_surv_rate_group();
 573     _surv_rate_group->record_surviving_words(age_in_group, words_survived);
 574   }
 575 




 233   HeapRegion* _humongous_start_region;
 234 
 235   // True iff an attempt to evacuate an object in the region failed.
 236   bool _evacuation_failed;
 237 
 238   // Fields used by the HeapRegionSetBase class and subclasses.
 239   HeapRegion* _next;
 240   HeapRegion* _prev;
 241 #ifdef ASSERT
 242   HeapRegionSetBase* _containing_set;
 243 #endif // ASSERT
 244 
 245   // We use concurrent marking to determine the amount of live data
 246   // in each heap region.
 247   size_t _prev_marked_bytes;    // Bytes known to be live via last completed marking.
 248   size_t _next_marked_bytes;    // Bytes known to be live via in-progress marking.
 249 
 250   // The calculated GC efficiency of the region.
 251   double _gc_efficiency;
 252 
 253   // The index in the optional regions array, if this region
 254   // is considered optional during a mixed collections.
 255   uint _index_in_opt_cset;
 256   int  _young_index_in_cset;
 257   SurvRateGroup* _surv_rate_group;
 258   int  _age_index;
 259 
 260   // The start of the unmarked area. The unmarked area extends from this
 261   // word until the top and/or end of the region, and is the part
 262   // of the region for which no marking was done, i.e. objects may
 263   // have been allocated in this part since the last mark phase.
 264   // "prev" is the top at the start of the last completed marking.
 265   // "next" is the top at the start of the in-progress marking (if any.)
 266   HeapWord* _prev_top_at_mark_start;
 267   HeapWord* _next_top_at_mark_start;
 268   // If a collection pause is in progress, this is the top at the start
 269   // of that pause.
 270 
 271   void init_top_at_mark_start() {
 272     assert(_prev_marked_bytes == 0 &&
 273            _next_marked_bytes == 0,
 274            "Must be called after zero_marked_bytes.");
 275     HeapWord* bot = bottom();


 539 
 540   // Notify the region that we are about to start processing
 541   // self-forwarded objects during evac failure handling.
 542   void note_self_forwarding_removal_start(bool during_initial_mark,
 543                                           bool during_conc_mark);
 544 
 545   // Notify the region that we have finished processing self-forwarded
 546   // objects during evac failure handling.
 547   void note_self_forwarding_removal_end(size_t marked_bytes);
 548 
 549   void reset_during_compaction() {
 550     assert(is_humongous(),
 551            "should only be called for humongous regions");
 552 
 553     zero_marked_bytes();
 554     init_top_at_mark_start();
 555   }
 556 
 557   void calc_gc_efficiency(void);
 558   double gc_efficiency() { return _gc_efficiency;}
 559 
 560   uint index_in_opt_cset() const { return _index_in_opt_cset; }
 561   void set_index_in_opt_cset(uint index) { _index_in_opt_cset = index; }
 562 
 563   int  young_index_in_cset() const { return _young_index_in_cset; }
 564   void set_young_index_in_cset(int index) {
 565     assert( (index == -1) || is_young(), "pre-condition" );
 566     _young_index_in_cset = index;
 567   }
 568 
 569   int age_in_surv_rate_group() {
 570     assert( _surv_rate_group != NULL, "pre-condition" );
 571     assert( _age_index > -1, "pre-condition" );
 572     return _surv_rate_group->age_in_group(_age_index);
 573   }
 574 
 575   void record_surv_words_in_group(size_t words_survived) {
 576     assert( _surv_rate_group != NULL, "pre-condition" );
 577     assert( _age_index > -1, "pre-condition" );
 578     int age_in_group = age_in_surv_rate_group();
 579     _surv_rate_group->record_surviving_words(age_in_group, words_survived);
 580   }
 581 


< prev index next >