< prev index next >

src/hotspot/share/gc/shared/collectorPolicy.cpp

Print this page




 153   size_t alignment = CardTableRS::ct_max_alignment_constraint();
 154 
 155   if (UseLargePages) {
 156       // In presence of large pages we have to make sure that our
 157       // alignment is large page aware.
 158       alignment = lcm(os::large_page_size(), alignment);
 159   }
 160 
 161   return alignment;
 162 }
 163 
 164 // GenCollectorPolicy methods
 165 
 166 GenCollectorPolicy::GenCollectorPolicy() :
 167     _min_young_size(0),
 168     _initial_young_size(0),
 169     _max_young_size(0),
 170     _min_old_size(0),
 171     _initial_old_size(0),
 172     _max_old_size(0),
 173     _gen_alignment(0),
 174     _young_gen_spec(NULL),
 175     _old_gen_spec(NULL)
 176 {}
 177 
 178 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
 179   return align_down_bounded(base_size / (NewRatio + 1), _gen_alignment);
 180 }
 181 
 182 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
 183                                                  size_t maximum_size) {
 184   size_t max_minus = maximum_size - _gen_alignment;
 185   return desired_size < max_minus ? desired_size : max_minus;
 186 }
 187 
 188 size_t GenCollectorPolicy::young_gen_size_lower_bound() {
 189   // The young generation must be aligned and have room for eden + two survivors
 190   return align_up(3 * _space_alignment, _gen_alignment);
 191 }
 192 
 193 size_t GenCollectorPolicy::old_gen_size_lower_bound() {
 194   return align_up(_space_alignment, _gen_alignment);
 195 }


 530     FLAG_SET_ERGO(size_t, MaxNewSize, _max_young_size);
 531   }
 532 
 533   if (OldSize != _initial_old_size) {
 534     FLAG_SET_ERGO(size_t, OldSize, _initial_old_size);
 535   }
 536 
 537   log_trace(gc, heap)("Minimum old " SIZE_FORMAT "  Initial old " SIZE_FORMAT "  Maximum old " SIZE_FORMAT,
 538                   _min_old_size, _initial_old_size, _max_old_size);
 539 
 540   DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
 541 }
 542 
 543 //
 544 // MarkSweepPolicy methods
 545 //
 546 
 547 void MarkSweepPolicy::initialize_alignments() {
 548   _space_alignment = _gen_alignment = (size_t)Generation::GenGrain;
 549   _heap_alignment = compute_heap_alignment();
 550 }
 551 
 552 void MarkSweepPolicy::initialize_generations() {
 553   _young_gen_spec = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size, _gen_alignment);
 554   _old_gen_spec   = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size, _gen_alignment);
 555 }
 556 
 557 void MarkSweepPolicy::initialize_gc_policy_counters() {
 558   // Initialize the policy counters - 2 collectors, 2 generations.
 559   _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 2);
 560 }


 153   size_t alignment = CardTableRS::ct_max_alignment_constraint();
 154 
 155   if (UseLargePages) {
 156       // In presence of large pages we have to make sure that our
 157       // alignment is large page aware.
 158       alignment = lcm(os::large_page_size(), alignment);
 159   }
 160 
 161   return alignment;
 162 }
 163 
 164 // GenCollectorPolicy methods
 165 
 166 GenCollectorPolicy::GenCollectorPolicy() :
 167     _min_young_size(0),
 168     _initial_young_size(0),
 169     _max_young_size(0),
 170     _min_old_size(0),
 171     _initial_old_size(0),
 172     _max_old_size(0),
 173     _gen_alignment(0)


 174 {}
 175 
 176 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
 177   return align_down_bounded(base_size / (NewRatio + 1), _gen_alignment);
 178 }
 179 
 180 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
 181                                                  size_t maximum_size) {
 182   size_t max_minus = maximum_size - _gen_alignment;
 183   return desired_size < max_minus ? desired_size : max_minus;
 184 }
 185 
 186 size_t GenCollectorPolicy::young_gen_size_lower_bound() {
 187   // The young generation must be aligned and have room for eden + two survivors
 188   return align_up(3 * _space_alignment, _gen_alignment);
 189 }
 190 
 191 size_t GenCollectorPolicy::old_gen_size_lower_bound() {
 192   return align_up(_space_alignment, _gen_alignment);
 193 }


 528     FLAG_SET_ERGO(size_t, MaxNewSize, _max_young_size);
 529   }
 530 
 531   if (OldSize != _initial_old_size) {
 532     FLAG_SET_ERGO(size_t, OldSize, _initial_old_size);
 533   }
 534 
 535   log_trace(gc, heap)("Minimum old " SIZE_FORMAT "  Initial old " SIZE_FORMAT "  Maximum old " SIZE_FORMAT,
 536                   _min_old_size, _initial_old_size, _max_old_size);
 537 
 538   DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
 539 }
 540 
 541 //
 542 // MarkSweepPolicy methods
 543 //
 544 
 545 void MarkSweepPolicy::initialize_alignments() {
 546   _space_alignment = _gen_alignment = (size_t)Generation::GenGrain;
 547   _heap_alignment = compute_heap_alignment();





 548 }
 549 
 550 void MarkSweepPolicy::initialize_gc_policy_counters() {
 551   // Initialize the policy counters - 2 collectors, 2 generations.
 552   _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 2);
 553 }
< prev index next >