hotspot/src/share/vm/gc/parallel/asPSYoungGen.cpp
changeset 46619 a3919f5e8d2b
parent 46565 8dcbf532ea00
child 46625 edefffab74e2
equal deleted inserted replaced
46618:d503911aa948 46619:a3919f5e8d2b
    73   size_t current_committed_size = virtual_space()->committed_size();
    73   size_t current_committed_size = virtual_space()->committed_size();
    74   assert((gen_size_limit() >= current_committed_size),
    74   assert((gen_size_limit() >= current_committed_size),
    75     "generation size limit is wrong");
    75     "generation size limit is wrong");
    76   ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
    76   ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
    77   size_t result =  gen_size_limit() - current_committed_size;
    77   size_t result =  gen_size_limit() - current_committed_size;
    78   size_t result_aligned = align_size_down(result, heap->generation_alignment());
    78   size_t result_aligned = align_down(result, heap->generation_alignment());
    79   return result_aligned;
    79   return result_aligned;
    80 }
    80 }
    81 
    81 
    82 // Return the number of bytes the young gen is willing give up.
    82 // Return the number of bytes the young gen is willing give up.
    83 //
    83 //
    96     const size_t gen_alignment = heap->generation_alignment();
    96     const size_t gen_alignment = heap->generation_alignment();
    97 
    97 
    98     assert(eden_space()->capacity_in_bytes() >= eden_alignment,
    98     assert(eden_space()->capacity_in_bytes() >= eden_alignment,
    99       "Alignment is wrong");
    99       "Alignment is wrong");
   100     size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment;
   100     size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment;
   101     eden_avail = align_size_down(eden_avail, gen_alignment);
   101     eden_avail = align_down(eden_avail, gen_alignment);
   102 
   102 
   103     assert(virtual_space()->committed_size() >= min_gen_size(),
   103     assert(virtual_space()->committed_size() >= min_gen_size(),
   104       "minimum gen size is wrong");
   104       "minimum gen size is wrong");
   105     size_t gen_avail = virtual_space()->committed_size() - min_gen_size();
   105     size_t gen_avail = virtual_space()->committed_size() - min_gen_size();
   106     assert(virtual_space()->is_aligned(gen_avail), "not aligned");
   106     assert(virtual_space()->is_aligned(gen_avail), "not aligned");
   108     const size_t max_contraction = MIN2(eden_avail, gen_avail);
   108     const size_t max_contraction = MIN2(eden_avail, gen_avail);
   109     // See comment for ASPSOldGen::available_for_contraction()
   109     // See comment for ASPSOldGen::available_for_contraction()
   110     // for reasons the "increment" fraction is used.
   110     // for reasons the "increment" fraction is used.
   111     PSAdaptiveSizePolicy* policy = heap->size_policy();
   111     PSAdaptiveSizePolicy* policy = heap->size_policy();
   112     size_t result = policy->eden_increment_aligned_down(max_contraction);
   112     size_t result = policy->eden_increment_aligned_down(max_contraction);
   113     size_t result_aligned = align_size_down(result, gen_alignment);
   113     size_t result_aligned = align_down(result, gen_alignment);
   114 
   114 
   115     log_trace(gc, ergo)("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", result_aligned/K);
   115     log_trace(gc, ergo)("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", result_aligned/K);
   116     log_trace(gc, ergo)("  max_contraction " SIZE_FORMAT " K", max_contraction/K);
   116     log_trace(gc, ergo)("  max_contraction " SIZE_FORMAT " K", max_contraction/K);
   117     log_trace(gc, ergo)("  eden_avail " SIZE_FORMAT " K", eden_avail/K);
   117     log_trace(gc, ergo)("  eden_avail " SIZE_FORMAT " K", eden_avail/K);
   118     log_trace(gc, ergo)("  gen_avail " SIZE_FORMAT " K", gen_avail/K);
   118     log_trace(gc, ergo)("  gen_avail " SIZE_FORMAT " K", gen_avail/K);
   164   assert(min_gen_size() <= orig_size && orig_size <= max_size(),
   164   assert(min_gen_size() <= orig_size && orig_size <= max_size(),
   165          "just checking");
   165          "just checking");
   166 
   166 
   167   // Adjust new generation size
   167   // Adjust new generation size
   168   const size_t eden_plus_survivors =
   168   const size_t eden_plus_survivors =
   169     align_size_up(eden_size + 2 * survivor_size, alignment);
   169     align_up(eden_size + 2 * survivor_size, alignment);
   170   size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()),
   170   size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()),
   171                              min_gen_size());
   171                              min_gen_size());
   172   assert(desired_size <= gen_size_limit(), "just checking");
   172   assert(desired_size <= gen_size_limit(), "just checking");
   173 
   173 
   174   if (desired_size > orig_size) {
   174   if (desired_size > orig_size) {
   330 
   330 
   331       // Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
   331       // Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
   332       if (from_size == 0) {
   332       if (from_size == 0) {
   333         from_size = alignment;
   333         from_size = alignment;
   334       } else {
   334       } else {
   335         from_size = align_size_up(from_size, alignment);
   335         from_size = align_up(from_size, alignment);
   336       }
   336       }
   337 
   337 
   338       from_end = from_start + from_size;
   338       from_end = from_start + from_size;
   339       assert(from_end > from_start, "addition overflow or from_size problem");
   339       assert(from_end > from_start, "addition overflow or from_size problem");
   340 
   340 
   417 
   417 
   418   guarantee((HeapWord*)from_start <= from_space()->bottom(),
   418   guarantee((HeapWord*)from_start <= from_space()->bottom(),
   419             "from start moved to the right");
   419             "from start moved to the right");
   420   guarantee((HeapWord*)from_end >= from_space()->top(),
   420   guarantee((HeapWord*)from_end >= from_space()->top(),
   421             "from end moved into live data");
   421             "from end moved into live data");
   422   assert(is_ptr_object_aligned(eden_start), "checking alignment");
   422   assert(is_object_aligned(eden_start), "checking alignment");
   423   assert(is_ptr_object_aligned(from_start), "checking alignment");
   423   assert(is_object_aligned(from_start), "checking alignment");
   424   assert(is_ptr_object_aligned(to_start), "checking alignment");
   424   assert(is_object_aligned(to_start), "checking alignment");
   425 
   425 
   426   MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
   426   MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
   427   MemRegion toMR  ((HeapWord*)to_start,   (HeapWord*)to_end);
   427   MemRegion toMR  ((HeapWord*)to_start,   (HeapWord*)to_end);
   428   MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
   428   MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
   429 
   429