< prev index next >

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

Print this page

        

@@ -73,11 +73,11 @@
   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());
+  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,11 +96,11 @@
     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);
+    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,11 +108,11 @@
     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);
+    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,11 +164,11 @@
   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);
+    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,11 +330,11 @@
 
       // 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_size = align_up(from_size, alignment);
       }
 
       from_end = from_start + from_size;
       assert(from_end > from_start, "addition overflow or from_size problem");
 

@@ -417,13 +417,13 @@
 
   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");
+  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);
 
< prev index next >