src/share/vm/memory/collectorPolicy.cpp

*** 103,113 ****
    return result;
  }
  
  GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
                                             int max_covered_regions) {
-   assert(rem_set_name() == GenRemSet::CardTable, "unrecognized GenRemSet::Name");
    return new CardTableRS(whole_heap, max_covered_regions);
  }
  
  void CollectorPolicy::cleared_all_soft_refs() {
    // If near gc overhear limit, continue to clear SoftRefs.  SoftRefs may
--- 103,112 ----
*** 145,159 ****
  }
  
  // GenCollectorPolicy methods.
  
  size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
!   size_t x = base_size / (NewRatio+1);
!   size_t new_gen_size = x > _min_alignment ?
!                      align_size_down(x, _min_alignment) :
!                      _min_alignment;
!   return new_gen_size;
  }
  
  size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
                                                   size_t maximum_size) {
    size_t alignment = _min_alignment;
--- 144,154 ----
  }
  
  // GenCollectorPolicy methods.
  
  size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
!   return align_size_down_bounded(base_size / (NewRatio + 1), _min_alignment);
  }
  
  size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
                                                   size_t maximum_size) {
    size_t alignment = _min_alignment;
*** 163,173 ****
  
  
  void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
                                                  size_t init_promo_size,
                                                  size_t init_survivor_size) {
!   const double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
    _size_policy = new AdaptiveSizePolicy(init_eden_size,
                                          init_promo_size,
                                          init_survivor_size,
                                          max_gc_pause_sec,
                                          GCTimeRatio);
--- 158,168 ----
  
  
  void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
                                                  size_t init_promo_size,
                                                  size_t init_survivor_size) {
!   const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
    _size_policy = new AdaptiveSizePolicy(init_eden_size,
                                          init_promo_size,
                                          init_survivor_size,
                                          max_gc_pause_sec,
                                          GCTimeRatio);
*** 195,204 ****
--- 190,200 ----
  
    if (NewSize < 3 * _min_alignment) {
       // make sure there room for eden and two survivor spaces
      vm_exit_during_initialization("Too small new size specified");
    }
+ 
    if (SurvivorRatio < 1 || NewRatio < 1) {
      vm_exit_during_initialization("Invalid young gen ratio specified");
    }
  }
  
*** 409,427 ****
  
    if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) {
      if ((heap_size < (*gen0_size_ptr + min_gen1_size)) &&
          (heap_size >= min_gen1_size + _min_alignment)) {
        // Adjust gen0 down to accommodate min_gen1_size
!       *gen0_size_ptr = heap_size - min_gen1_size;
!       *gen0_size_ptr =
!         MAX2((uintx)align_size_down(*gen0_size_ptr, _min_alignment), _min_alignment);
        assert(*gen0_size_ptr > 0, "Min gen0 is too large");
        result = true;
      } else {
!       *gen1_size_ptr = heap_size - *gen0_size_ptr;
!       *gen1_size_ptr =
!         MAX2((uintx)align_size_down(*gen1_size_ptr, _min_alignment), _min_alignment);
      }
    }
    return result;
  }
  
--- 405,419 ----
  
    if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) {
      if ((heap_size < (*gen0_size_ptr + min_gen1_size)) &&
          (heap_size >= min_gen1_size + _min_alignment)) {
        // Adjust gen0 down to accommodate min_gen1_size
!       *gen0_size_ptr = align_size_down_bounded(heap_size - min_gen1_size, _min_alignment);
        assert(*gen0_size_ptr > 0, "Min gen0 is too large");
        result = true;
      } else {
!       *gen1_size_ptr = align_size_down_bounded(heap_size - *gen0_size_ptr, _min_alignment);
      }
    }
    return result;
  }
  
*** 472,482 ****
      if ((_min_gen1_size + _min_gen0_size + _min_alignment) < _min_heap_byte_size) {
        warning("Inconsistency between minimum heap size and minimum "
                "generation sizes: using minimum heap = " SIZE_FORMAT,
                _min_heap_byte_size);
      }
!     if ((OldSize > _max_gen1_size)) {
        warning("Inconsistency between maximum heap size and maximum "
                "generation sizes: using maximum heap = " SIZE_FORMAT
                " -XX:OldSize flag is being ignored",
                _max_heap_byte_size);
      }
--- 464,474 ----
      if ((_min_gen1_size + _min_gen0_size + _min_alignment) < _min_heap_byte_size) {
        warning("Inconsistency between minimum heap size and minimum "
                "generation sizes: using minimum heap = " SIZE_FORMAT,
                _min_heap_byte_size);
      }
!     if (OldSize > _max_gen1_size) {
        warning("Inconsistency between maximum heap size and maximum "
                "generation sizes: using maximum heap = " SIZE_FORMAT
                " -XX:OldSize flag is being ignored",
                _max_heap_byte_size);
      }
*** 603,615 ****
  
        // Read the gc count while the heap lock is held.
        gc_count_before = Universe::heap()->total_collections();
      }
  
!     VM_GenCollectForAllocation op(size,
!                                   is_tlab,
!                                   gc_count_before);
      VMThread::execute(&op);
      if (op.prologue_succeeded()) {
        result = op.result();
        if (op.gc_locked()) {
           assert(result == NULL, "must be NULL if gc_locked() is true");
--- 595,605 ----
  
        // Read the gc count while the heap lock is held.
        gc_count_before = Universe::heap()->total_collections();
      }
  
!     VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
      VMThread::execute(&op);
      if (op.prologue_succeeded()) {
        result = op.result();
        if (op.gc_locked()) {
           assert(result == NULL, "must be NULL if gc_locked() is true");
*** 840,861 ****
    initialize_all();
  }
  
  void MarkSweepPolicy::initialize_generations() {
    _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, 0, AllocFailStrategy::RETURN_NULL);
!   if (_generations == NULL)
      vm_exit_during_initialization("Unable to allocate gen spec");
  
    if (UseParNewGC) {
      _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
    } else {
      _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
    }
    _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
  
!   if (_generations[0] == NULL || _generations[1] == NULL)
      vm_exit_during_initialization("Unable to allocate gen spec");
  }
  
  void MarkSweepPolicy::initialize_gc_policy_counters() {
    // initialize the policy counters - 2 collectors, 3 generations
    if (UseParNewGC) {
--- 830,853 ----
    initialize_all();
  }
  
  void MarkSweepPolicy::initialize_generations() {
    _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, 0, AllocFailStrategy::RETURN_NULL);
!   if (_generations == NULL) {
      vm_exit_during_initialization("Unable to allocate gen spec");
+   }
  
    if (UseParNewGC) {
      _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
    } else {
      _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
    }
    _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
  
!   if (_generations[0] == NULL || _generations[1] == NULL) {
      vm_exit_during_initialization("Unable to allocate gen spec");
+   }
  }
  
  void MarkSweepPolicy::initialize_gc_policy_counters() {
    // initialize the policy counters - 2 collectors, 3 generations
    if (UseParNewGC) {