Align double array backing store during compaction and mark-sweep promotion.

src/mark-compact.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 1997 matching lines @@
       }
 
       offset++;
       current_cell >>= 1;
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(object, size)) {
         continue;
       }
 
       // Promotion failed. Just migrate object to another semispace.
-      MaybeObject* allocation = new_space->AllocateRaw(size);
+      int allocation_size = size;
+      if (Heap::MustBeDoubleAligned(object))  {
+        ASSERT(kObjectAlignment != kDoubleAlignment);
+        allocation_size += kPointerSize;

[Michael Starzinger, 2013/11/14 13:37:46]

Hmm, could this end up using more space in the to-space than was used in the
from-space? Imagine every object in the from-space survives and promotion fails.
Every object was allocated with the inline allocation sequence that doesn't
over-allocate to align. With this alignment strategy every object will consume
one additional word in to-space.

I realize that this is a highly constructed scenario, and that we already have
that problem with the existing EvacuateObject implementation. But it leads me to
believe that a better way of implementing the alignment within the GC would be
to make sure the top-pointer is aligned before we allocate.

[dusmil, 2013/12/13 16:06:15]

Yes, this is very unlikely, but it might happen. Currently, I think the only way
to keep allocation top aligned and to avoid this scenario is to round up object
sizes to multiple of 8, thus setting allocation granularity to 8 bytes, but this
will have impact on memory footprint. At least we can try the experiment for
MIPS only, as we will additionally get aligned heap numbers that way.

Regarding code duplication for alignment handling, it can be sorted out by
moving double alignment handling code in AllocateRaw routines and pass to the
additional flag, but this change will be more intrusive.

+      }
+      MaybeObject* allocation = new_space->AllocateRaw(allocation_size);
       if (allocation->IsFailure()) {
         if (!new_space->AddFreshPage()) {
           // Shouldn't happen. We are sweeping linearly, and to-space
           // has the same number of pages as from-space, so there is
           // always room.
           UNREACHABLE();
         }
-        allocation = new_space->AllocateRaw(size);
+        allocation = new_space->AllocateRaw(allocation_size);
         ASSERT(!allocation->IsFailure());
       }
-      Object* target = allocation->ToObjectUnchecked();
-
-      MigrateObject(HeapObject::cast(target)->address(),
+      Object* result = allocation->ToObjectUnchecked();
+      HeapObject* target = HeapObject::cast(result);
+      if (Heap::MustBeDoubleAligned(object))  {
+        target = heap()->EnsureDoubleAligned(target, allocation_size);
+      }
+      MigrateObject(target->address(),
                     object->address(),
                     size,
                     NEW_SPACE);
     }
     *cells = 0;
   }
   return survivors_size;
 }
 
 
@@ skipping 885 matching lines @@
 
   return String::cast(*p);
 }
 
 
 bool MarkCompactCollector::TryPromoteObject(HeapObject* object,
                                             int object_size) {
   // TODO(hpayer): Replace that check with an assert.
   CHECK(object_size <= Page::kMaxNonCodeHeapObjectSize);
 
+  int allocation_size = object_size;
+  if (Heap::MustBeDoubleAligned(object))  {
+    ASSERT(kObjectAlignment != kDoubleAlignment);
+    allocation_size += kPointerSize;

[Michael Starzinger, 2013/11/14 13:37:46]

This might exceed Page::kMaxNonCodeHeapObjectSize.

[dusmil, 2013/12/13 16:06:15]

According to the definition of Page::kMaxNonCodeHeapObjectSize double alignment
is taken into account.

static const int kMaxNonCodeHeapObjectSize =
      kNonCodeObjectAreaSize - kPointerSize;

So, this CHECK could be changed to CHECK(object_size <=
Page::kNonCodeObjectAreaSize) and move after alignment handling.

+  }
   OldSpace* target_space = heap()->TargetSpace(object);
 
   ASSERT(target_space == heap()->old_pointer_space() ||
          target_space == heap()->old_data_space());
   Object* result;
   MaybeObject* maybe_result = target_space->AllocateRaw(
-      object_size,
+      allocation_size,
       PagedSpace::MOVE_OBJECT);
   if (maybe_result->ToObject(&result)) {
     HeapObject* target = HeapObject::cast(result);
+    if (Heap::MustBeDoubleAligned(object))  {
+      target = heap()->EnsureDoubleAligned(target, allocation_size);
+    }
     MigrateObject(target->address(),
                   object->address(),
                   object_size,
                   target_space->identity());
     heap()->mark_compact_collector()->tracer()->
         increment_promoted_objects_size(object_size);
     return true;
   }
 
   return false;
@@ skipping 50 matching lines @@
     if (*cell == 0) continue;
 
     int live_objects = MarkWordToObjectStarts(*cell, offsets);
     for (int i = 0; i < live_objects; i++) {
       Address object_addr = cell_base + offsets[i] * kPointerSize;
       HeapObject* object = HeapObject::FromAddress(object_addr);
       ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
 
       int size = object->Size();
 
-      MaybeObject* target = space->AllocateRaw(size, PagedSpace::MOVE_OBJECT);
+      int allocation_size = size;
+      if (Heap::MustBeDoubleAligned(object))  {
+        ASSERT(kObjectAlignment != kDoubleAlignment);
+        allocation_size += kPointerSize;
+      }
+      MaybeObject* target =
+          space->AllocateRaw(allocation_size, PagedSpace::MOVE_OBJECT);
       if (target->IsFailure()) {
         // OS refused to give us memory.
         V8::FatalProcessOutOfMemory("Evacuation");
         return;
       }
 
-      Object* target_object = target->ToObjectUnchecked();
-
-      MigrateObject(HeapObject::cast(target_object)->address(),
+      Object* result = target->ToObjectUnchecked();
+      HeapObject* target_object = HeapObject::cast(result);
+      if (Heap::MustBeDoubleAligned(object)) {
+        target_object =
+            heap()->EnsureDoubleAligned(target_object, allocation_size);
+      }
+      MigrateObject(target_object->address(),
                     object_addr,
                     size,
                     space->identity());
       ASSERT(object->map_word().IsForwardingAddress());
     }
 
     // Clear marking bits for current cell.
     *cell = 0;
   }
   p->ResetLiveBytes();
@@ skipping 1316 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal