Precise sweeping makes zapping of garbage memory when trimming arrays obsolete

src/heap/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/once.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 3242 matching lines @@
       Marking::IsBlack(Marking::MarkBitFrom(address))) {
     if (mode == FROM_GC) {
       MemoryChunk::IncrementLiveBytesFromGC(address, by);
     } else {
       MemoryChunk::IncrementLiveBytesFromMutator(address, by);
     }
   }
 }
 
 
-static void ZapFixedArrayForTrimming(Address address, int elements_to_trim) {
-  Object** zap = reinterpret_cast<Object**>(address);
-  zap++;  // Header of filler must be at least one word so skip that.
-  for (int i = 1; i < elements_to_trim; i++) {
-    *zap++ = Smi::FromInt(0);
-  }
-}
-
-
 FixedArrayBase* Heap::LeftTrimFixedArray(FixedArrayBase* object,
                                          int elements_to_trim) {
   const int element_size = object->IsFixedArray() ? kPointerSize : kDoubleSize;
   const int bytes_to_trim = elements_to_trim * element_size;
   Map* map = object->map();
 
   // For now this trick is only applied to objects in new and paged space.
   // In large object space the object's start must coincide with chunk
   // and thus the trick is just not applicable.
   DCHECK(!lo_space()->Contains(object));
   DCHECK(object->map() != fixed_cow_array_map());
 
   STATIC_ASSERT(FixedArrayBase::kMapOffset == 0);
   STATIC_ASSERT(FixedArrayBase::kLengthOffset == kPointerSize);
   STATIC_ASSERT(FixedArrayBase::kHeaderSize == 2 * kPointerSize);
 
   const int len = object->length();
   DCHECK(elements_to_trim <= len);
 
   // Calculate location of new array start.
   Address new_start = object->address() + bytes_to_trim;
 
-  if (bytes_to_trim > FreeSpace::kHeaderSize &&
-      object->IsFixedArray() &&
-      !new_space()->Contains(object)) {
-    // If we are doing a big trim in old space then we zap the space that was
-    // formerly part of the array so that the GC (aided by the card-based
-    // remembered set) won't find pointers to new-space there.
-    ZapFixedArrayForTrimming(object->address(), elements_to_trim);
-  }
-
   // Technically in new space this write might be omitted (except for
   // debug mode which iterates through the heap), but to play safer
   // we still do it.
   CreateFillerObjectAt(object->address(), bytes_to_trim);
 
   // Initialize header of the trimmed array. Since left trimming is only
   // performed on pages which are not concurrently swept creating a filler
   // object does not require synchronization.
   DCHECK(CanMoveObjectStart(object));
   Object** former_start = HeapObject::RawField(object, 0);
@@ skipping 28 matching lines @@
   // For now this trick is only applied to objects in new and paged space.
   DCHECK(!lo_space()->Contains(object));
   DCHECK(object->map() != fixed_cow_array_map());
 
   const int len = object->length();
   DCHECK(elements_to_trim < len);
 
   // Calculate location of new array end.
   Address new_end = object->address() + object->Size() - bytes_to_trim;
 
-  if (bytes_to_trim > FreeSpace::kHeaderSize &&
-      object->IsFixedArray() &&
-      (mode != Heap::FROM_GC || Heap::ShouldZapGarbage())) {
-    // If we are doing a big trim in old space then we zap the space that was
-    // formerly part of the array so that the GC (aided by the card-based
-    // remembered set) won't find pointers to new-space there.
-    ZapFixedArrayForTrimming(new_end, elements_to_trim);
-  }
-
   // Technically in new space this write might be omitted (except for
   // debug mode which iterates through the heap), but to play safer
   // we still do it.
   CreateFillerObjectAt(new_end, bytes_to_trim);
 
   // Initialize header of the trimmed array. We are storing the new length
   // using release store after creating a filler for the left-over space to
   // avoid races with the sweeper thread.
   object->synchronized_set_length(len - elements_to_trim);
 
@@ skipping 2800 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal