Clean up aligned allocation code in preparation for SIMD alignments.

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1766 matching lines @@
   CHECK_EQ(initial_size, static_cast<int>(CcTest::heap()->SizeOfObjects()));
 
   // Waiting for sweeper threads should not change heap size.
   if (collector->sweeping_in_progress()) {
     collector->EnsureSweepingCompleted();
   }
   CHECK_EQ(initial_size, static_cast<int>(CcTest::heap()->SizeOfObjects()));
 }
 
 
+TEST(TestAlignmentCalculations) {
+  // Maximum fill amounts should be consistent.
+  int maximum_double_misalignment = kDoubleSize - kPointerSize;
+  int max_word_fill = Heap::GetMaximumFillToAlign(kWordAligned);
+  CHECK_EQ(0, max_word_fill);
+  int max_double_fill = Heap::GetMaximumFillToAlign(kDoubleAligned);
+  CHECK_EQ(maximum_double_misalignment, max_double_fill);
+  int max_double_unaligned_fill = Heap::GetMaximumFillToAlign(kDoubleUnaligned);
+  CHECK_EQ(maximum_double_misalignment, max_double_unaligned_fill);
+
+  Address base = reinterpret_cast<Address>(NULL);
+  int fill = 0;
+
+  // Word alignment never requires fill.
+  fill = Heap::GetFillToAlign(base, kWordAligned);
+  CHECK_EQ(0, fill);
+  fill = Heap::GetFillToAlign(base + kPointerSize, kWordAligned);
+  CHECK_EQ(0, fill);
+
+  // No fill is required when address is double aligned.
+  fill = Heap::GetFillToAlign(base, kDoubleAligned);
+  CHECK_EQ(0, fill);
+  // Fill is required if address is not double aligned.
+  fill = Heap::GetFillToAlign(base + kPointerSize, kDoubleAligned);
+  CHECK_EQ(maximum_double_misalignment, fill);
+  // kDoubleUnaligned has the opposite fill amounts.
+  fill = Heap::GetFillToAlign(base, kDoubleUnaligned);
+  CHECK_EQ(maximum_double_misalignment, fill);
+  fill = Heap::GetFillToAlign(base + kPointerSize, kDoubleUnaligned);
+  CHECK_EQ(0, fill);
+}
+
+
+static HeapObject* AllocateAligned(int size, AllocationAlignment alignment) {
+  Heap* heap = CcTest::heap();
+  AllocationResult allocation =
+      heap->new_space()->AllocateRawAligned(size, alignment);
+  HeapObject* obj = NULL;
+  allocation.To(&obj);
+  heap->CreateFillerObjectAt(obj->address(), size);
+  return obj;
+}
+
+
+TEST(TestAlignedAllocation) {
+  // Double misalignment is 4 on 32-bit platforms, 0 on 64-bit ones.
+  const intptr_t double_misalignment = kDoubleSize - kPointerSize;
+  if (double_misalignment) {
+    // Allocate a pointer sized object that must be double aligned.
+    Address* top_addr = CcTest::heap()->new_space()->allocation_top_address();
+    Address start = *top_addr;
+    HeapObject* obj1 = AllocateAligned(kPointerSize, kDoubleAligned);
+    CHECK(IsAddressAligned(obj1->address(), kDoubleAlignment, 0));
+    // Allocate a second pointer sized object. These two allocations should
+    // cause exactly one filler object to be created.

[Hannes Payer (out of office), 2015/05/27 14:12:45]

Let's also check if the filler is there.

[bbudge, 2015/05/28 09:28:33]

Done.

+    HeapObject* obj2 = AllocateAligned(kPointerSize, kDoubleAligned);
+    CHECK(IsAddressAligned(obj2->address(), kDoubleAlignment, 0));
+    CHECK_EQ(2 * kPointerSize + double_misalignment, *top_addr - start);
+
+    // Similarly for kDoubleUnaligned.
+    start = *top_addr;
+    obj1 = AllocateAligned(kPointerSize, kDoubleUnaligned);
+    CHECK(IsAddressAligned(obj1->address(), kDoubleAlignment, kPointerSize));

[Hannes Payer (out of office), 2015/05/27 14:12:45]

This address should not be double aligned.

[bbudge, 2015/05/28 09:28:33]

address + offset is aligned

(confusing, I'm not a fan of this utility function)

+    obj2 = AllocateAligned(kPointerSize, kDoubleUnaligned);
+    CHECK(IsAddressAligned(obj2->address(), kDoubleAlignment, kPointerSize));
+    CHECK_EQ(2 * kPointerSize + double_misalignment, *top_addr - start);
+  }
+}
+
+
+static HeapObject* AllocateUnalignedAndFill(int size, int allocated,
+                                            AllocationAlignment alignment) {
+  Heap* heap = CcTest::heap();
+  AllocationResult allocation =
+      heap->new_space()->AllocateRawUnaligned(allocated);
+  HeapObject* obj = NULL;
+  allocation.To(&obj);
+  obj = heap->AlignWithFiller(obj, kPointerSize, allocated, kDoubleAligned);
+  heap->CreateFillerObjectAt(obj->address(), size);
+  return obj;
+}
+
+
+TEST(TestAlignedOverAllocation) {
+  // Double misalignment is 4 on 32-bit platforms, 0 on 64-bit ones.
+  const intptr_t double_misalignment = kDoubleSize - kPointerSize;
+  if (double_misalignment) {
+    Address* top_addr = CcTest::heap()->new_space()->allocation_top_address();
+    Address start = *top_addr;
+    HeapObject* obj1 = AllocateUnalignedAndFill(

[Hannes Payer (out of office), 2015/05/27 14:12:45]

Here, I would rather test the free-list allocation and check if the object is a
the right alignment and the fillers are e.g. before and after the object.

[bbudge, 2015/05/28 09:28:33]

Done.

+        kPointerSize, kPointerSize + double_misalignment, kDoubleAligned);
+    CHECK(IsAddressAligned(obj1->address(), kDoubleAlignment, 0));
+    CHECK((start == obj1->address()) ||
+          (start == obj1->address() + double_misalignment));
+  }
+}
+
+
 TEST(TestSizeOfObjectsVsHeapIteratorPrecision) {
   CcTest::InitializeVM();
   HeapIterator iterator(CcTest::heap());
   intptr_t size_of_objects_1 = CcTest::heap()->SizeOfObjects();
   intptr_t size_of_objects_2 = 0;
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
     if (!obj->IsFreeSpace()) {
       size_of_objects_2 += obj->Size();
@@ skipping 3754 matching lines @@
   size_t counter2 = 2000;
   tracer->SampleNewSpaceAllocation(time2, counter2);
   size_t bytes = tracer->NewSpaceAllocatedBytesInLast(1000);
   CHECK_EQ(10000, bytes);
   int time3 = 1000;
   size_t counter3 = 30000;
   tracer->SampleNewSpaceAllocation(time3, counter3);
   bytes = tracer->NewSpaceAllocatedBytesInLast(100);
   CHECK_EQ((counter3 - counter1) * 100 / (time3 - time1), bytes);
 }