8255298: Remove SurvivorAlignmentInBytes functionality

Reviewed-by: shade, ayang, kbarrett

Author: Thomas Schatzl

src/hotspot/share/gc/g1/g1Allocator.cpp

@@ -281,22 +281,9 @@ HeapWord* G1Allocator::old_attempt_allocation(size_t min_word_size,
   return result;
 }
 
-uint G1PLABAllocator::calc_survivor_alignment_bytes() {
-  assert(SurvivorAlignmentInBytes >= ObjectAlignmentInBytes, "sanity");
-  if (SurvivorAlignmentInBytes == ObjectAlignmentInBytes) {
-    // No need to align objects in the survivors differently, return 0
-    // which means "survivor alignment is not used".
-    return 0;
-  } else {
-    assert(SurvivorAlignmentInBytes > 0, "sanity");
-    return SurvivorAlignmentInBytes;
-  }
-}
-
 G1PLABAllocator::G1PLABAllocator(G1Allocator* allocator) :
   _g1h(G1CollectedHeap::heap()),
-  _allocator(allocator),
-  _survivor_alignment_bytes(calc_survivor_alignment_bytes()) {
+  _allocator(allocator) {
   for (region_type_t state = 0; state < G1HeapRegionAttr::Num; state++) {
     _direct_allocated[state] = 0;
     uint length = alloc_buffers_length(state);

src/hotspot/share/gc/g1/g1Allocator.hpp

@@ -149,13 +149,6 @@ class G1PLABAllocator : public CHeapObj<mtGC> {
 
   PLAB** _alloc_buffers[G1HeapRegionAttr::Num];
 
-  // The survivor alignment in effect in bytes.
-  // == 0 : don't align survivors
-  // != 0 : align survivors to that alignment
-  // These values were chosen to favor the non-alignment case since some
-  // architectures have a special compare against zero instructions.
-  const uint _survivor_alignment_bytes;
-
   // Number of words allocated directly (not counting PLAB allocation).
   size_t _direct_allocated[G1HeapRegionAttr::Num];
 
@@ -168,10 +161,6 @@ class G1PLABAllocator : public CHeapObj<mtGC> {
   // active NUMA nodes.
   inline uint alloc_buffers_length(region_type_t dest) const;
 
-  // Calculate the survivor space object alignment in bytes. Returns that or 0 if
-  // there are no restrictions on survivor alignment.
-  static uint calc_survivor_alignment_bytes();
-
   bool may_throw_away_buffer(size_t const allocation_word_sz, size_t const buffer_size) const;
 public:
   G1PLABAllocator(G1Allocator* allocator);

src/hotspot/share/gc/g1/g1Allocator.inline.hpp

@@ -105,11 +105,7 @@ inline HeapWord* G1PLABAllocator::plab_allocate(G1HeapRegionAttr dest,
                                                 size_t word_sz,
                                                 uint node_index) {
   PLAB* buffer = alloc_buffer(dest, node_index);
-  if (_survivor_alignment_bytes == 0 || !dest.is_young()) {
-    return buffer->allocate(word_sz);
-  } else {
-    return buffer->allocate_aligned(word_sz, _survivor_alignment_bytes);
-  }
+  return buffer->allocate(word_sz);
 }
 
 inline HeapWord* G1PLABAllocator::allocate(G1HeapRegionAttr dest,

src/hotspot/share/gc/parallel/psPromotionLAB.inline.hpp

@@ -32,20 +32,14 @@
 HeapWord* PSYoungPromotionLAB::allocate(size_t size) {
   // Can't assert this, when young fills, we keep the LAB around, but flushed.
   // assert(_state != flushed, "Sanity");
-  HeapWord* obj = CollectedHeap::align_allocation_or_fail(top(), end(), SurvivorAlignmentInBytes);
-  if (obj == NULL) {
-    return NULL;
-  }
-
+  HeapWord* obj = top();
   HeapWord* new_top = obj + size;
   // The 'new_top>obj' check is needed to detect overflow of obj+size.
   if (new_top > obj && new_top <= end()) {
     set_top(new_top);
-    assert(is_aligned(obj, SurvivorAlignmentInBytes) && is_object_aligned(new_top),
-           "checking alignment");
+    assert(is_object_aligned(new_top), "checking alignment");
     return obj;
   } else {
-    set_top(obj);
     return NULL;
   }
 }

src/hotspot/share/gc/serial/defNewGeneration.cpp

@@ -711,7 +711,7 @@ oop DefNewGeneration::copy_to_survivor_space(oop old) {
 
   // Try allocating obj in to-space (unless too old)
   if (old->age() < tenuring_threshold()) {
-    obj = (oop) to()->allocate_aligned(s);
+    obj = (oop) to()->allocate(s);
   }
 
   // Otherwise try allocating obj tenured

src/hotspot/share/gc/shared/collectedHeap.hpp

@@ -310,12 +310,6 @@ class CollectedHeap : public CHeapObj<mtInternal> {
   virtual size_t min_dummy_object_size() const;
   size_t tlab_alloc_reserve() const;
 
-  // Return the address "addr" aligned by "alignment_in_bytes" if such
-  // an address is below "end".  Return NULL otherwise.
-  inline static HeapWord* align_allocation_or_fail(HeapWord* addr,
-                                                   HeapWord* end,
-                                                   unsigned short alignment_in_bytes);
-
   // Some heaps may offer a contiguous region for shared non-blocking
   // allocation, via inlined code (by exporting the address of the top and
   // end fields defining the extent of the contiguous allocation region.)

src/hotspot/share/gc/shared/collectedHeap.inline.hpp

@@ -30,43 +30,6 @@
 #include "oops/oop.inline.hpp"
 #include "utilities/align.hpp"
 
-inline HeapWord* CollectedHeap::align_allocation_or_fail(HeapWord* addr,
-                                                         HeapWord* end,
-                                                         unsigned short alignment_in_bytes) {
-  if (alignment_in_bytes <= ObjectAlignmentInBytes) {
-    return addr;
-  }
-
-  assert(is_aligned(addr, HeapWordSize),
-         "Address " PTR_FORMAT " is not properly aligned.", p2i(addr));
-  assert(is_aligned(alignment_in_bytes, HeapWordSize),
-         "Alignment size %u is incorrect.", alignment_in_bytes);
-
-  HeapWord* new_addr = align_up(addr, alignment_in_bytes);
-  size_t padding = pointer_delta(new_addr, addr);
-
-  if (padding == 0) {
-    return addr;
-  }
-
-  if (padding < CollectedHeap::min_fill_size()) {
-    padding += alignment_in_bytes / HeapWordSize;
-    assert(padding >= CollectedHeap::min_fill_size(),
-           "alignment_in_bytes %u is expect to be larger "
-           "than the minimum object size", alignment_in_bytes);
-    new_addr = addr + padding;
-  }
-
-  assert(new_addr > addr, "Unexpected arithmetic overflow "
-         PTR_FORMAT " not greater than " PTR_FORMAT, p2i(new_addr), p2i(addr));
-  if(new_addr < end) {
-    CollectedHeap::fill_with_object(addr, padding);
-    return new_addr;
-  } else {
-    return NULL;
-  }
-}
-
 inline oop CollectedHeap::obj_allocate(Klass* klass, int size, TRAPS) {
   ObjAllocator allocator(klass, size, THREAD);
   return allocator.allocate();

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

@@ -438,22 +438,3 @@ JVMFlag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
   }
 }
 
-JVMFlag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose) {
-  if (value != 0) {
-    if (!is_power_of_2(value)) {
-      JVMFlag::printError(verbose,
-                          "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
-                          "power of 2\n",
-                          value);
-      return JVMFlag::VIOLATES_CONSTRAINT;
-    }
-    if (value < ObjectAlignmentInBytes) {
-      JVMFlag::printError(verbose,
-                          "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
-                          "greater than or equal to ObjectAlignmentInBytes (" INTX_FORMAT ")\n",
-                          value, ObjectAlignmentInBytes);
-      return JVMFlag::VIOLATES_CONSTRAINT;
-    }
-  }
-  return JVMFlag::SUCCESS;
-}

src/hotspot/share/gc/shared/jvmFlagConstraintsGC.hpp

@@ -67,8 +67,7 @@
  f(uintx,  TLABWasteIncrementConstraintFunc)                   \
  f(uintx,  SurvivorRatioConstraintFunc)                        \
  f(size_t, MetaspaceSizeConstraintFunc)                        \
- f(size_t, MaxMetaspaceSizeConstraintFunc)                     \
- f(intx,   SurvivorAlignmentInBytesConstraintFunc)
+ f(size_t, MaxMetaspaceSizeConstraintFunc)
 
 SHARED_GC_CONSTRAINTS(DECLARE_CONSTRAINT)
 

src/hotspot/share/gc/shared/plab.inline.hpp

@@ -30,18 +30,6 @@
 #include "memory/allocation.inline.hpp"
 #include "runtime/atomic.hpp"
 
-inline HeapWord* PLAB::allocate_aligned(size_t word_sz, unsigned short alignment_in_bytes) {
-  HeapWord* res = CollectedHeap::align_allocation_or_fail(_top, _end, alignment_in_bytes);
-  if (res == NULL) {
-    return NULL;
-  }
-
-  // Set _top so that allocate(), which expects _top to be correctly set,
-  // can be used below.
-  _top = res;
-  return allocate(word_sz);
-}
-
 void PLABStats::add_allocated(size_t v) {
   Atomic::add(&_allocated, v);
 }