[heap] Pass a force_promotion flag to the evacuation routine in the scavenger.

src/heap/scavenger.cc

 // Copyright 2015 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/heap/scavenger.h"
 
 #include "src/contexts.h"
 #include "src/heap/heap.h"
 #include "src/heap/objects-visiting-inl.h"
 #include "src/heap/scavenger-inl.h"
@@ skipping 182 matching lines @@
         heap->promotion_queue()->insert(
             target, object_size,
             Marking::IsBlack(Marking::MarkBitFrom(object)));
       }
       heap->IncrementPromotedObjectsSize(object_size);
       return true;
     }
     return false;
   }
 
-
   template <ObjectContents object_contents, AllocationAlignment alignment>
   static inline void EvacuateObject(Map* map, HeapObject** slot,
-                                    HeapObject* object, int object_size) {
+                                    HeapObject* object, int object_size,
+                                    PromotionMode promotion_mode) {
     SLOW_DCHECK(object_size <= Page::kAllocatableMemory);
     SLOW_DCHECK(object->Size() == object_size);
     Heap* heap = map->GetHeap();
 
-    if (!heap->ShouldBePromoted(object->address(), object_size)) {
+    if (promotion_mode != FORCE_PROMOTION &&
+        !heap->ShouldBePromoted(object->address(), object_size)) {
       // A semi-space copy may fail due to fragmentation. In that case, we
       // try to promote the object.
       if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
         return;
       }
     }
 
     if (PromoteObject<object_contents, alignment>(map, slot, object,
                                                   object_size)) {
       return;
     }
-
+    if (promotion_mode == FORCE_PROMOTION) {
+      FatalProcessOutOfMemory("Scavenger: forced promotion\n");
+    }
     // If promotion failed, we try to copy the object to the other semi-space
     if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) return;
 
     FatalProcessOutOfMemory("Scavenger: semi-space copy\n");
   }
 
-
   static inline void EvacuateJSFunction(Map* map, HeapObject** slot,
-                                        HeapObject* object) {
-    ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object);
+                                        HeapObject* object,
+                                        PromotionMode promotion_mode) {
+    ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object,
+                                                    promotion_mode);
 
     if (marks_handling == IGNORE_MARKS) return;
 
     MapWord map_word = object->map_word();
     DCHECK(map_word.IsForwardingAddress());
     HeapObject* target = map_word.ToForwardingAddress();
 
     MarkBit mark_bit = Marking::MarkBitFrom(target);
     if (Marking::IsBlack(mark_bit)) {
       // This object is black and it might not be rescanned by marker.
       // We should explicitly record code entry slot for compaction because
       // promotion queue processing (IteratePromotedObjectPointers) will
       // miss it as it is not HeapObject-tagged.
       Address code_entry_slot =
           target->address() + JSFunction::kCodeEntryOffset;
       Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
       map->GetHeap()->mark_compact_collector()->RecordCodeEntrySlot(
           target, code_entry_slot, code);
     }
   }
 
-
   static inline void EvacuateFixedArray(Map* map, HeapObject** slot,
-                                        HeapObject* object) {
+                                        HeapObject* object,
+                                        PromotionMode promotion_mode) {
     int length = reinterpret_cast<FixedArray*>(object)->synchronized_length();
     int object_size = FixedArray::SizeFor(length);
-    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object,
-                                                 object_size);
+    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                                 promotion_mode);
   }
 
-
   static inline void EvacuateFixedDoubleArray(Map* map, HeapObject** slot,
-                                              HeapObject* object) {
+                                              HeapObject* object,
+                                              PromotionMode promotion_mode) {
     int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
     int object_size = FixedDoubleArray::SizeFor(length);
-    EvacuateObject<DATA_OBJECT, kDoubleAligned>(map, slot, object, object_size);
+    EvacuateObject<DATA_OBJECT, kDoubleAligned>(map, slot, object, object_size,
+                                                promotion_mode);
   }
 
-
   static inline void EvacuateFixedTypedArray(Map* map, HeapObject** slot,
-                                             HeapObject* object) {
+                                             HeapObject* object,
+                                             PromotionMode promotion_mode) {
     int object_size = reinterpret_cast<FixedTypedArrayBase*>(object)->size();
-    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object,
-                                                 object_size);
+    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                                 promotion_mode);
   }
 
-
   static inline void EvacuateFixedFloat64Array(Map* map, HeapObject** slot,
-                                               HeapObject* object) {
+                                               HeapObject* object,
+                                               PromotionMode promotion_mode) {
     int object_size = reinterpret_cast<FixedFloat64Array*>(object)->size();
     EvacuateObject<POINTER_OBJECT, kDoubleAligned>(map, slot, object,
-                                                   object_size);
+                                                   object_size, promotion_mode);
   }
 
-
   static inline void EvacuateJSArrayBuffer(Map* map, HeapObject** slot,
-                                           HeapObject* object) {
-    ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object);
+                                           HeapObject* object,
+                                           PromotionMode promotion_mode) {
+    ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object,
+                                                    promotion_mode);
 
     Heap* heap = map->GetHeap();
     MapWord map_word = object->map_word();
     DCHECK(map_word.IsForwardingAddress());
     HeapObject* target = map_word.ToForwardingAddress();
     if (!heap->InNewSpace(target)) {
       heap->array_buffer_tracker()->Promote(JSArrayBuffer::cast(target));
     }
   }
 
-
   static inline void EvacuateByteArray(Map* map, HeapObject** slot,
-                                       HeapObject* object) {
+                                       HeapObject* object,
+                                       PromotionMode promotion_mode) {
     int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize();
-    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size);
+    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                              promotion_mode);
   }
 
-
   static inline void EvacuateSeqOneByteString(Map* map, HeapObject** slot,
-                                              HeapObject* object) {
+                                              HeapObject* object,
+                                              PromotionMode promotion_mode) {
     int object_size = SeqOneByteString::cast(object)
                           ->SeqOneByteStringSize(map->instance_type());
-    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size);
+    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                              promotion_mode);
   }
 
-
   static inline void EvacuateSeqTwoByteString(Map* map, HeapObject** slot,
-                                              HeapObject* object) {
+                                              HeapObject* object,
+                                              PromotionMode promotion_mode) {
     int object_size = SeqTwoByteString::cast(object)
                           ->SeqTwoByteStringSize(map->instance_type());
-    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size);
+    EvacuateObject<DATA_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                              promotion_mode);
   }
 
-
   static inline void EvacuateShortcutCandidate(Map* map, HeapObject** slot,
-                                               HeapObject* object) {
+                                               HeapObject* object,
+                                               PromotionMode promotion_mode) {
     DCHECK(IsShortcutCandidate(map->instance_type()));
 
     Heap* heap = map->GetHeap();
 
     if (marks_handling == IGNORE_MARKS &&
         ConsString::cast(object)->unchecked_second() == heap->empty_string()) {
       HeapObject* first =
           HeapObject::cast(ConsString::cast(object)->unchecked_first());
 
       *slot = first;
 
       if (!heap->InNewSpace(first)) {
         object->set_map_word(MapWord::FromForwardingAddress(first));
         return;
       }
 
       MapWord first_word = first->map_word();
       if (first_word.IsForwardingAddress()) {
         HeapObject* target = first_word.ToForwardingAddress();
 
         *slot = target;
         object->set_map_word(MapWord::FromForwardingAddress(target));
         return;
       }
 
-      Scavenger::ScavengeObjectSlow(slot, first);
+      Scavenger::ScavengeObjectSlow(slot, first, promotion_mode);
       object->set_map_word(MapWord::FromForwardingAddress(*slot));
       return;
     }
 
     int object_size = ConsString::kSize;
-    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object,
-                                                 object_size);
+    EvacuateObject<POINTER_OBJECT, kWordAligned>(map, slot, object, object_size,
+                                                 promotion_mode);
   }
 
   template <ObjectContents object_contents>
   class ObjectEvacuationStrategy {
    public:
     template <int object_size>
     static inline void VisitSpecialized(Map* map, HeapObject** slot,
-                                        HeapObject* object) {
-      EvacuateObject<object_contents, kWordAligned>(map, slot, object,
-                                                    object_size);
+                                        HeapObject* object,
+                                        PromotionMode promotion_mode) {
+      EvacuateObject<object_contents, kWordAligned>(
+          map, slot, object, object_size, promotion_mode);
     }
 
-    static inline void Visit(Map* map, HeapObject** slot, HeapObject* object) {
+    static inline void Visit(Map* map, HeapObject** slot, HeapObject* object,
+                             PromotionMode promotion_mode) {
       int object_size = map->instance_size();
-      EvacuateObject<object_contents, kWordAligned>(map, slot, object,
-                                                    object_size);
+      EvacuateObject<object_contents, kWordAligned>(
+          map, slot, object, object_size, promotion_mode);
     }
   };
 
   static VisitorDispatchTable<ScavengingCallback> table_;
 };
 
 
 template <MarksHandling marks_handling,
           LoggingAndProfiling logging_and_profiling_mode>
 VisitorDispatchTable<ScavengingCallback>
     ScavengingVisitor<marks_handling, logging_and_profiling_mode>::table_;
 
 
 // static
 void Scavenger::Initialize() {
   ScavengingVisitor<TRANSFER_MARKS,
                     LOGGING_AND_PROFILING_DISABLED>::Initialize();
   ScavengingVisitor<IGNORE_MARKS, LOGGING_AND_PROFILING_DISABLED>::Initialize();
   ScavengingVisitor<TRANSFER_MARKS,
                     LOGGING_AND_PROFILING_ENABLED>::Initialize();
   ScavengingVisitor<IGNORE_MARKS, LOGGING_AND_PROFILING_ENABLED>::Initialize();
 }
 
 
 // static
-void Scavenger::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
+void Scavenger::ScavengeObjectSlow(HeapObject** p, HeapObject* object,
+                                   PromotionMode promotion_mode) {
   SLOW_DCHECK(object->GetIsolate()->heap()->InFromSpace(object));
   MapWord first_word = object->map_word();
   SLOW_DCHECK(!first_word.IsForwardingAddress());
   Map* map = first_word.ToMap();
   Scavenger* scavenger = map->GetHeap()->scavenge_collector_;
-  scavenger->scavenging_visitors_table_.GetVisitor(map)(map, p, object);
+  scavenger->scavenging_visitors_table_.GetVisitor(map)(map, p, object,
+                                                        promotion_mode);
 }
 
 
 void Scavenger::SelectScavengingVisitorsTable() {
   bool logging_and_profiling =
       FLAG_verify_predictable || isolate()->logger()->is_logging() ||
       isolate()->cpu_profiler()->is_profiling() ||
       (isolate()->heap_profiler() != NULL &&
        isolate()->heap_profiler()->is_tracking_object_moves());
 
@@ skipping 46 matching lines @@
 
 void ScavengeVisitor::ScavengePointer(Object** p) {
   Object* object = *p;
   if (!heap_->InNewSpace(object)) return;
   Scavenger::ScavengeObject(reinterpret_cast<HeapObject**>(p),
                             reinterpret_cast<HeapObject*>(object));
 }
 
 }  // namespace internal
 }  // namespace v8