Filter old to new references when moving parts of an object.

src/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 659 matching lines @@
 void Heap::PerformScavenge() {
   GCTracer tracer(this, NULL, NULL);
   if (incremental_marking()->IsStopped()) {
     PerformGarbageCollection(SCAVENGER, &tracer);
   } else {
     PerformGarbageCollection(MARK_COMPACTOR, &tracer);
   }
 }
 
 
+void Heap::MoveElements(FixedArray* dst, int dst_index, FixedArray* src,
+                        int src_index, int len) {
+  if (len == 0) return;
+
+  ASSERT(dst->map() != HEAP->fixed_cow_array_map());
+  Object** dst_objects = dst->data_start() + dst_index;
+  memmove(dst_objects,
+          src->data_start() + src_index,
+          len * kPointerSize);
+  for (int i = 0; i < len; i++) {
+    if (!InNewSpace(src) && InNewSpace(dst_objects[i])) {

[Michael Starzinger, 2013/01/08 13:46:32]

As discussed offline, this second loop is no longer cache-local because it
interleaves access to the store-buffer with access to the destination. I am fine
with landing this for now if it doesn't regress until we optimize the
store-buffer access, but please leave a TODO comment here.

Also the InNewSpace(src) check can be hoisted out of the loop, because I am not
sure GCC is smart enough to do that.

[Hannes Payer (out of office), 2013/01/09 09:32:46]

I will submit an optimization in a follow-up CL.
Done.

+      RecordWrite(dst->address(), dst->OffsetOfElementAt(dst_index + i));
+    }
+  }
+  incremental_marking()->RecordWrites(dst);
+}
+
+
 #ifdef VERIFY_HEAP
 // Helper class for verifying the symbol table.
 class SymbolTableVerifier : public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
       if ((*p)->IsHeapObject()) {
         // Check that the symbol is actually a symbol.
         CHECK((*p)->IsTheHole() || (*p)->IsUndefined() || (*p)->IsSymbol());
@@ skipping 4276 matching lines @@
 
 
 MUST_USE_RESULT static MaybeObject* AllocateFixedArrayWithFiller(
     Heap* heap,
     int length,
     PretenureFlag pretenure,
     Object* filler) {
   ASSERT(length >= 0);
   ASSERT(heap->empty_fixed_array()->IsFixedArray());
   if (length == 0) return heap->empty_fixed_array();
-
   ASSERT(!heap->InNewSpace(filler));
   Object* result;
   { MaybeObject* maybe_result = heap->AllocateRawFixedArray(length, pretenure);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
   HeapObject::cast(result)->set_map_no_write_barrier(heap->fixed_array_map());
   FixedArray* array = FixedArray::cast(result);
   array->set_length(length);
   MemsetPointer(array->data_start(), filler, length);
@@ skipping 2369 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal