< prev index next >

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

Print this page
rev 57223 : imported patch 8225484-changes-to-survivor-calculation


 102 
 103   guarantee(CardsPerRegion == 0, "we should only set it once");
 104   CardsPerRegion = GrainBytes >> G1CardTable::card_shift;
 105 
 106   LogCardsPerRegion = log2_long((jlong) CardsPerRegion);
 107 
 108   if (G1HeapRegionSize != GrainBytes) {
 109     FLAG_SET_ERGO(G1HeapRegionSize, GrainBytes);
 110   }
 111 }
 112 
 113 void HeapRegion::hr_clear(bool keep_remset, bool clear_space, bool locked) {
 114   assert(_humongous_start_region == NULL,
 115          "we should have already filtered out humongous regions");
 116   assert(!in_collection_set(),
 117          "Should not clear heap region %u in the collection set", hrm_index());
 118 
 119   clear_young_index_in_cset();
 120   clear_index_in_opt_cset();
 121   uninstall_surv_rate_group();

 122   set_free();
 123   reset_pre_dummy_top();
 124 
 125   if (!keep_remset) {
 126     if (locked) {
 127       rem_set()->clear_locked();
 128     } else {
 129       rem_set()->clear();
 130     }
 131   }
 132 
 133   zero_marked_bytes();
 134 
 135   init_top_at_mark_start();
 136   if (clear_space) clear(SpaceDecorator::Mangle);
 137 
 138   _evacuation_failed = false;
 139   _gc_efficiency = 0.0;
 140 }
 141 


 234                        MemRegion mr) :
 235   _bottom(mr.start()),
 236   _end(mr.end()),
 237   _top(NULL),
 238   _compaction_top(NULL),
 239   _bot_part(bot, this),
 240   _par_alloc_lock(Mutex::leaf, "HeapRegion par alloc lock", true),
 241   _pre_dummy_top(NULL),
 242   _rem_set(NULL),
 243   _hrm_index(hrm_index),
 244   _type(),
 245   _humongous_start_region(NULL),
 246   _evacuation_failed(false),
 247   _index_in_opt_cset(InvalidCSetIndex),
 248   _next(NULL), _prev(NULL),
 249 #ifdef ASSERT
 250   _containing_set(NULL),
 251 #endif
 252   _prev_top_at_mark_start(NULL), _next_top_at_mark_start(NULL),
 253   _prev_marked_bytes(0), _next_marked_bytes(0),

 254   _young_index_in_cset(-1),
 255   _surv_rate_group(NULL), _age_index(G1SurvRateGroup::InvalidAgeIndex), _gc_efficiency(0.0),
 256   _node_index(G1NUMA::UnknownNodeIndex)
 257 {
 258   assert(Universe::on_page_boundary(mr.start()) && Universe::on_page_boundary(mr.end()),
 259          "invalid space boundaries");
 260 
 261   _rem_set = new HeapRegionRemSet(bot, this);
 262   initialize();
 263 }
 264 
 265 void HeapRegion::initialize(bool clear_space, bool mangle_space) {
 266   assert(_rem_set->is_empty(), "Remembered set must be empty");
 267 
 268   if (clear_space) {
 269     clear(mangle_space);
 270   }
 271 
 272   set_top(bottom());
 273   set_compaction_top(bottom());




 102 
 103   guarantee(CardsPerRegion == 0, "we should only set it once");
 104   CardsPerRegion = GrainBytes >> G1CardTable::card_shift;
 105 
 106   LogCardsPerRegion = log2_long((jlong) CardsPerRegion);
 107 
 108   if (G1HeapRegionSize != GrainBytes) {
 109     FLAG_SET_ERGO(G1HeapRegionSize, GrainBytes);
 110   }
 111 }
 112 
 113 void HeapRegion::hr_clear(bool keep_remset, bool clear_space, bool locked) {
 114   assert(_humongous_start_region == NULL,
 115          "we should have already filtered out humongous regions");
 116   assert(!in_collection_set(),
 117          "Should not clear heap region %u in the collection set", hrm_index());
 118 
 119   clear_young_index_in_cset();
 120   clear_index_in_opt_cset();
 121   uninstall_surv_rate_group();
 122   _survivor_bytes = 0;
 123   set_free();
 124   reset_pre_dummy_top();
 125 
 126   if (!keep_remset) {
 127     if (locked) {
 128       rem_set()->clear_locked();
 129     } else {
 130       rem_set()->clear();
 131     }
 132   }
 133 
 134   zero_marked_bytes();
 135 
 136   init_top_at_mark_start();
 137   if (clear_space) clear(SpaceDecorator::Mangle);
 138 
 139   _evacuation_failed = false;
 140   _gc_efficiency = 0.0;
 141 }
 142 


 235                        MemRegion mr) :
 236   _bottom(mr.start()),
 237   _end(mr.end()),
 238   _top(NULL),
 239   _compaction_top(NULL),
 240   _bot_part(bot, this),
 241   _par_alloc_lock(Mutex::leaf, "HeapRegion par alloc lock", true),
 242   _pre_dummy_top(NULL),
 243   _rem_set(NULL),
 244   _hrm_index(hrm_index),
 245   _type(),
 246   _humongous_start_region(NULL),
 247   _evacuation_failed(false),
 248   _index_in_opt_cset(InvalidCSetIndex),
 249   _next(NULL), _prev(NULL),
 250 #ifdef ASSERT
 251   _containing_set(NULL),
 252 #endif
 253   _prev_top_at_mark_start(NULL), _next_top_at_mark_start(NULL),
 254   _prev_marked_bytes(0), _next_marked_bytes(0),
 255   _survivor_bytes(0),
 256   _young_index_in_cset(-1),
 257   _surv_rate_group(NULL), _age_index(G1SurvRateGroup::InvalidAgeIndex), _gc_efficiency(0.0),
 258   _node_index(G1NUMA::UnknownNodeIndex)
 259 {
 260   assert(Universe::on_page_boundary(mr.start()) && Universe::on_page_boundary(mr.end()),
 261          "invalid space boundaries");
 262 
 263   _rem_set = new HeapRegionRemSet(bot, this);
 264   initialize();
 265 }
 266 
 267 void HeapRegion::initialize(bool clear_space, bool mangle_space) {
 268   assert(_rem_set->is_empty(), "Remembered set must be empty");
 269 
 270   if (clear_space) {
 271     clear(mangle_space);
 272   }
 273 
 274   set_top(bottom());
 275   set_compaction_top(bottom());


< prev index next >