Just visit young array buffers during scavenge.

src/heap/objects-visiting.cc

 // Copyright 2011 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/heap/objects-visiting.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 173 matching lines @@
   return heap->gc_state() == Heap::MARK_COMPACT &&
          heap->mark_compact_collector()->is_compacting();
 }
 
 
 template <class T>
 struct WeakListVisitor;
 
 
 template <class T>
-Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer) {
+Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer,
+                      Object* last_young_object,
+                      Object** last_young_object_recorded) {
   Object* undefined = heap->undefined_value();
   Object* head = undefined;
   T* tail = NULL;
   MarkCompactCollector* collector = heap->mark_compact_collector();
   bool record_slots = MustRecordSlots(heap);
+  bool last_young_object_found = false;
   while (list != undefined) {
     // Check whether to keep the candidate in the list.
     T* candidate = reinterpret_cast<T*>(list);
+    if (last_young_object && !last_young_object_found) {
+      last_young_object_found = last_young_object == candidate;
+    }
+
     Object* retained = retainer->RetainAs(list);
     if (retained != NULL) {
       if (head == undefined) {
         // First element in the list.
         head = retained;
       } else {
         // Subsequent elements in the list.
         DCHECK(tail != NULL);
         WeakListVisitor<T>::SetWeakNext(tail, retained);
         if (record_slots) {
           Object** next_slot =
               HeapObject::RawField(tail, WeakListVisitor<T>::WeakNextOffset());
           collector->RecordSlot(next_slot, next_slot, retained);
         }
       }
       // Retained object is new tail.
       DCHECK(!retained->IsUndefined());
       candidate = reinterpret_cast<T*>(retained);
       tail = candidate;
 
 
       // tail is a live object, visit it.
       WeakListVisitor<T>::VisitLiveObject(heap, tail, retainer);
     } else {
       WeakListVisitor<T>::VisitPhantomObject(heap, candidate);
     }
 
+    if (last_young_object_recorded && !heap->InNewSpace(retained)) {
+      *last_young_object_recorded = retained;
+    }
+
+    // The list of weak objects is usually order. It starts with objects
+    // recently allocated in the young generation followed by objects
+    // allocated in the old generation.
+    // For young generation collections we just have to visit until the last
+    // young generation objects.
+    if (last_young_object_found && retained) {
+      return head;
+    }
+
     // Move to next element in the list.
     list = WeakListVisitor<T>::WeakNext(candidate);
   }
 
   // Terminate the list if there is one or more elements.
   if (tail != NULL) {
     WeakListVisitor<T>::SetWeakNext(tail, undefined);
   }
+
   return head;
 }
 
 
 template <class T>
 static void ClearWeakList(Heap* heap, Object* list) {
   Object* undefined = heap->undefined_value();
   while (list != undefined) {
     T* candidate = reinterpret_cast<T*>(list);
     list = WeakListVisitor<T>::WeakNext(candidate);
@@ skipping 61 matching lines @@
     if (heap->gc_state() == Heap::MARK_COMPACT) {
       DoWeakList<Code>(heap, context, retainer, Context::OPTIMIZED_CODE_LIST);
       DoWeakList<Code>(heap, context, retainer, Context::DEOPTIMIZED_CODE_LIST);
     }
   }
 
   template <class T>
   static void DoWeakList(Heap* heap, Context* context,
                          WeakObjectRetainer* retainer, int index) {
     // Visit the weak list, removing dead intermediate elements.
-    Object* list_head = VisitWeakList<T>(heap, context->get(index), retainer);
+    Object* list_head =
+        VisitWeakList<T>(heap, context->get(index), retainer, NULL, NULL);
 
     // Update the list head.
     context->set(index, list_head, UPDATE_WRITE_BARRIER);
 
     if (MustRecordSlots(heap)) {
       // Record the updated slot if necessary.
       Object** head_slot =
           HeapObject::RawField(context, FixedArray::SizeFor(index));
       heap->mark_compact_collector()->RecordSlot(head_slot, head_slot,
                                                  list_head);
@@ skipping 31 matching lines @@
     obj->set_weak_next(next);
   }
 
   static Object* WeakNext(JSArrayBuffer* obj) { return obj->weak_next(); }
 
   static int WeakNextOffset() { return JSArrayBuffer::kWeakNextOffset; }
 
   static void VisitLiveObject(Heap* heap, JSArrayBuffer* array_buffer,
                               WeakObjectRetainer* retainer) {
     Object* typed_array_obj = VisitWeakList<JSArrayBufferView>(
-        heap, array_buffer->weak_first_view(), retainer);
+        heap, array_buffer->weak_first_view(), retainer, NULL, NULL);
     array_buffer->set_weak_first_view(typed_array_obj);
     if (typed_array_obj != heap->undefined_value() && MustRecordSlots(heap)) {
       Object** slot = HeapObject::RawField(array_buffer,
                                            JSArrayBuffer::kWeakFirstViewOffset);
       heap->mark_compact_collector()->RecordSlot(slot, slot, typed_array_obj);
     }
   }
 
   static void VisitPhantomObject(Heap* heap, JSArrayBuffer* phantom) {
     Runtime::FreeArrayBuffer(heap->isolate(), phantom);
@@ skipping 10 matching lines @@
   static Object* WeakNext(AllocationSite* obj) { return obj->weak_next(); }
 
   static int WeakNextOffset() { return AllocationSite::kWeakNextOffset; }
 
   static void VisitLiveObject(Heap*, AllocationSite*, WeakObjectRetainer*) {}
 
   static void VisitPhantomObject(Heap*, AllocationSite*) {}
 };
 
 
-template Object* VisitWeakList<Code>(Heap* heap, Object* list,
-                                     WeakObjectRetainer* retainer);
+template Object* VisitWeakList<Context>(Heap* heap, Object* list,
+                                        WeakObjectRetainer* retainer,
+                                        Object* last_young_object,
+                                        Object** last_young_object_recorded);
 
 
-template Object* VisitWeakList<JSFunction>(Heap* heap, Object* list,
-                                           WeakObjectRetainer* retainer);
+template Object* VisitWeakList<JSArrayBuffer>(
+    Heap* heap, Object* list, WeakObjectRetainer* retainer,
+    Object* last_young_object, Object** last_young_object_recorded);
 
 
-template Object* VisitWeakList<Context>(Heap* heap, Object* list,
-                                        WeakObjectRetainer* retainer);
-
-
-template Object* VisitWeakList<JSArrayBuffer>(Heap* heap, Object* list,
-                                              WeakObjectRetainer* retainer);
-
-
-template Object* VisitWeakList<AllocationSite>(Heap* heap, Object* list,
-                                               WeakObjectRetainer* retainer);
+template Object* VisitWeakList<AllocationSite>(
+    Heap* heap, Object* list, WeakObjectRetainer* retainer,
+    Object* last_young_object, Object** last_young_object_recorded);
 }
 }  // namespace v8::internal