src/share/vm/gc/parallel/asPSYoungGen.cpp

*** 73,83 ****
    size_t current_committed_size = virtual_space()->committed_size();
    assert((gen_size_limit() >= current_committed_size),
      "generation size limit is wrong");
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
    size_t result =  gen_size_limit() - current_committed_size;
!   size_t result_aligned = align_size_down(result, heap->generation_alignment());
    return result_aligned;
  }
  
  // Return the number of bytes the young gen is willing give up.
  //
--- 73,83 ----
    size_t current_committed_size = virtual_space()->committed_size();
    assert((gen_size_limit() >= current_committed_size),
      "generation size limit is wrong");
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
    size_t result =  gen_size_limit() - current_committed_size;
!   size_t result_aligned = align_down(result, heap->generation_alignment());
    return result_aligned;
  }
  
  // Return the number of bytes the young gen is willing give up.
  //
*** 96,106 ****
      const size_t gen_alignment = heap->generation_alignment();
  
      assert(eden_space()->capacity_in_bytes() >= eden_alignment,
        "Alignment is wrong");
      size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment;
!     eden_avail = align_size_down(eden_avail, gen_alignment);
  
      assert(virtual_space()->committed_size() >= min_gen_size(),
        "minimum gen size is wrong");
      size_t gen_avail = virtual_space()->committed_size() - min_gen_size();
      assert(virtual_space()->is_aligned(gen_avail), "not aligned");
--- 96,106 ----
      const size_t gen_alignment = heap->generation_alignment();
  
      assert(eden_space()->capacity_in_bytes() >= eden_alignment,
        "Alignment is wrong");
      size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment;
!     eden_avail = align_down(eden_avail, gen_alignment);
  
      assert(virtual_space()->committed_size() >= min_gen_size(),
        "minimum gen size is wrong");
      size_t gen_avail = virtual_space()->committed_size() - min_gen_size();
      assert(virtual_space()->is_aligned(gen_avail), "not aligned");
*** 108,118 ****
      const size_t max_contraction = MIN2(eden_avail, gen_avail);
      // See comment for ASPSOldGen::available_for_contraction()
      // for reasons the "increment" fraction is used.
      PSAdaptiveSizePolicy* policy = heap->size_policy();
      size_t result = policy->eden_increment_aligned_down(max_contraction);
!     size_t result_aligned = align_size_down(result, gen_alignment);
  
      log_trace(gc, ergo)("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", result_aligned/K);
      log_trace(gc, ergo)("  max_contraction " SIZE_FORMAT " K", max_contraction/K);
      log_trace(gc, ergo)("  eden_avail " SIZE_FORMAT " K", eden_avail/K);
      log_trace(gc, ergo)("  gen_avail " SIZE_FORMAT " K", gen_avail/K);
--- 108,118 ----
      const size_t max_contraction = MIN2(eden_avail, gen_avail);
      // See comment for ASPSOldGen::available_for_contraction()
      // for reasons the "increment" fraction is used.
      PSAdaptiveSizePolicy* policy = heap->size_policy();
      size_t result = policy->eden_increment_aligned_down(max_contraction);
!     size_t result_aligned = align_down(result, gen_alignment);
  
      log_trace(gc, ergo)("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", result_aligned/K);
      log_trace(gc, ergo)("  max_contraction " SIZE_FORMAT " K", max_contraction/K);
      log_trace(gc, ergo)("  eden_avail " SIZE_FORMAT " K", eden_avail/K);
      log_trace(gc, ergo)("  gen_avail " SIZE_FORMAT " K", gen_avail/K);
*** 164,174 ****
    assert(min_gen_size() <= orig_size && orig_size <= max_size(),
           "just checking");
  
    // Adjust new generation size
    const size_t eden_plus_survivors =
!     align_size_up(eden_size + 2 * survivor_size, alignment);
    size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()),
                               min_gen_size());
    assert(desired_size <= gen_size_limit(), "just checking");
  
    if (desired_size > orig_size) {
--- 164,174 ----
    assert(min_gen_size() <= orig_size && orig_size <= max_size(),
           "just checking");
  
    // Adjust new generation size
    const size_t eden_plus_survivors =
!     align_up(eden_size + 2 * survivor_size, alignment);
    size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()),
                               min_gen_size());
    assert(desired_size <= gen_size_limit(), "just checking");
  
    if (desired_size > orig_size) {
*** 330,340 ****
  
        // Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
        if (from_size == 0) {
          from_size = alignment;
        } else {
!         from_size = align_size_up(from_size, alignment);
        }
  
        from_end = from_start + from_size;
        assert(from_end > from_start, "addition overflow or from_size problem");
  
--- 330,340 ----
  
        // Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
        if (from_size == 0) {
          from_size = alignment;
        } else {
!         from_size = align_up(from_size, alignment);
        }
  
        from_end = from_start + from_size;
        assert(from_end > from_start, "addition overflow or from_size problem");
  
*** 417,429 ****
  
    guarantee((HeapWord*)from_start <= from_space()->bottom(),
              "from start moved to the right");
    guarantee((HeapWord*)from_end >= from_space()->top(),
              "from end moved into live data");
!   assert(is_ptr_object_aligned(eden_start), "checking alignment");
!   assert(is_ptr_object_aligned(from_start), "checking alignment");
!   assert(is_ptr_object_aligned(to_start), "checking alignment");
  
    MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
    MemRegion toMR  ((HeapWord*)to_start,   (HeapWord*)to_end);
    MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
  
--- 417,429 ----
  
    guarantee((HeapWord*)from_start <= from_space()->bottom(),
              "from start moved to the right");
    guarantee((HeapWord*)from_end >= from_space()->top(),
              "from end moved into live data");
!   assert(is_object_aligned(eden_start), "checking alignment");
!   assert(is_object_aligned(from_start), "checking alignment");
!   assert(is_object_aligned(to_start), "checking alignment");
  
    MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
    MemRegion toMR  ((HeapWord*)to_start,   (HeapWord*)to_end);
    MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);