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);
 }

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

@@ -567,27 +567,6 @@ inline HeapWord* ContiguousSpace::par_allocate_impl(size_t size) {
   } while (true);
 }
 
-HeapWord* ContiguousSpace::allocate_aligned(size_t size) {
-  assert(Heap_lock->owned_by_self() || (SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()), "not locked");
-  HeapWord* end_value = end();
-
-  HeapWord* obj = CollectedHeap::align_allocation_or_fail(top(), end_value, SurvivorAlignmentInBytes);
-  if (obj == NULL) {
-    return NULL;
-  }
-
-  if (pointer_delta(end_value, obj) >= size) {
-    HeapWord* new_top = obj + size;
-    set_top(new_top);
-    assert(::is_aligned(obj, SurvivorAlignmentInBytes) && is_aligned(new_top),
-      "checking alignment");
-    return obj;
-  } else {
-    set_top(obj);
-    return NULL;
-  }
-}
-
 // Requires locking.
 HeapWord* ContiguousSpace::allocate(size_t size) {
   return allocate_impl(size);

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

@@ -560,7 +560,6 @@ class ContiguousSpace: public CompactibleSpace {
   // Allocation (return NULL if full)
   virtual HeapWord* allocate(size_t word_size);
   virtual HeapWord* par_allocate(size_t word_size);
-  HeapWord* allocate_aligned(size_t word_size);
 
   // Iteration
   void oop_iterate(OopIterateClosure* cl);

src/hotspot/share/runtime/arguments.cpp

@@ -1659,10 +1659,6 @@ void set_object_alignment() {
 
   // Oop encoding heap max
   OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes;
-
-  if (SurvivorAlignmentInBytes == 0) {
-    SurvivorAlignmentInBytes = ObjectAlignmentInBytes;
-  }
 }
 
 size_t Arguments::max_heap_for_compressed_oops() {

src/hotspot/share/runtime/globals.hpp

@@ -2393,11 +2393,6 @@ const intx ObjectAlignmentInBytes = 8;
   product(bool, WhiteBoxAPI, false, DIAGNOSTIC,                             \
           "Enable internal testing APIs")                                   \
                                                                             \
-  product(intx, SurvivorAlignmentInBytes, 0, EXPERIMENTAL,                  \
-           "Default survivor space alignment in bytes")                     \
-           range(8, 256)                                                    \
-           constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo)     \
-                                                                            \
   product(ccstr, DumpLoadedClassList, NULL,                                 \
           "Dump the names all loaded classes, that could be stored into "   \
           "the CDS archive, in the specified file")                         \

test/hotspot/jtreg/TEST.groups

@@ -202,7 +202,6 @@ tier1_gc_2 = \
   -gc/g1/ \
   -gc/logging/TestUnifiedLoggingSwitchStress.java \
   -gc/stress \
-  -gc/survivorAlignment/TestPromotionFromSurvivorToTenuredAfterMinorGC.java \
   -gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java \
   -gc/shenandoah \
   -gc/nvdimm