[heap] Parallel newspace evacuation, semispace copy, and compaction \o/

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/heap/heap.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/ast/scopeinfo.h"
 #include "src/base/bits.h"
@@ skipping 419 matching lines @@
     gc_count_++;
 
 #ifdef VERIFY_HEAP
     if (FLAG_verify_heap) {
       Verify();
     }
 #endif
   }
 
   // Reset GC statistics.
-  promoted_objects_size_ = 0;
-  previous_semi_space_copied_object_size_ = semi_space_copied_object_size_;
-  semi_space_copied_object_size_ = 0;
+  promoted_objects_size_.SetValue(0);
+  previous_semi_space_copied_object_size_ = semi_space_copied_object_size();
+  semi_space_copied_object_size_.SetValue(0);
   nodes_died_in_new_space_ = 0;
   nodes_copied_in_new_space_ = 0;
   nodes_promoted_ = 0;
 
   UpdateMaximumCommitted();
 
 #ifdef DEBUG
   DCHECK(!AllowHeapAllocation::IsAllowed() && gc_state_ == NOT_IN_GC);
 
   if (FLAG_gc_verbose) Print();
@@ skipping 59 matching lines @@
     const HashMap& local_pretenuring_feedback) {
   AllocationSite* site = nullptr;
   for (HashMap::Entry* local_entry = local_pretenuring_feedback.Start();
        local_entry != nullptr;
        local_entry = local_pretenuring_feedback.Next(local_entry)) {
     site = reinterpret_cast<AllocationSite*>(local_entry->key);
     MapWord map_word = site->map_word();
     if (map_word.IsForwardingAddress()) {
       site = AllocationSite::cast(map_word.ToForwardingAddress());
     }
-    DCHECK(site->IsAllocationSite());
+
+    // We have not validated the allocation site yet, since we have not
+    // dereferenced the site during collecting information.
+    // This is an inlined check of AllocationMemento::IsValid.
+    if (!site->IsAllocationSite() || site->IsZombie()) continue;
+
     int value =
         static_cast<int>(reinterpret_cast<intptr_t>(local_entry->value));
     DCHECK_GT(value, 0);
 
-    {
-      // TODO(mlippautz): For parallel processing we need synchronization here.
-      if (site->IncrementMementoFoundCount(value)) {
-        global_pretenuring_feedback_->LookupOrInsert(
-            site, static_cast<uint32_t>(bit_cast<uintptr_t>(site)));
-      }
+    if (site->IncrementMementoFoundCount(value)) {
+      global_pretenuring_feedback_->LookupOrInsert(
+          site, static_cast<uint32_t>(bit_cast<uintptr_t>(site)));
     }
   }
 }
 
 
 class Heap::PretenuringScope {
  public:
   explicit PretenuringScope(Heap* heap) : heap_(heap) {
     heap_->global_pretenuring_feedback_ =
         new HashMap(HashMap::PointersMatch, kInitialFeedbackCapacity);
@@ skipping 684 matching lines @@
       NormalizedMapCache::cast(cache)->Clear();
     }
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
   }
 }
 
 
 void Heap::UpdateSurvivalStatistics(int start_new_space_size) {
   if (start_new_space_size == 0) return;
 
-  promotion_ratio_ = (static_cast<double>(promoted_objects_size_) /
+  promotion_ratio_ = (static_cast<double>(promoted_objects_size()) /
                       static_cast<double>(start_new_space_size) * 100);
 
   if (previous_semi_space_copied_object_size_ > 0) {
     promotion_rate_ =
-        (static_cast<double>(promoted_objects_size_) /
+        (static_cast<double>(promoted_objects_size()) /
          static_cast<double>(previous_semi_space_copied_object_size_) * 100);
   } else {
     promotion_rate_ = 0;
   }
 
   semi_space_copied_rate_ =
-      (static_cast<double>(semi_space_copied_object_size_) /
+      (static_cast<double>(semi_space_copied_object_size()) /
        static_cast<double>(start_new_space_size) * 100);
 
   double survival_rate = promotion_ratio_ + semi_space_copied_rate_;
   tracer()->AddSurvivalRatio(survival_rate);
   if (survival_rate > kYoungSurvivalRateHighThreshold) {
     high_survival_rate_period_length_++;
   } else {
     high_survival_rate_period_length_ = 0;
   }
 }
@@ skipping 42 matching lines @@
 
     if (collector == MARK_COMPACTOR) {
       UpdateOldGenerationAllocationCounter();
       // Perform mark-sweep with optional compaction.
       MarkCompact();
       old_gen_exhausted_ = false;
       old_generation_size_configured_ = true;
       // This should be updated before PostGarbageCollectionProcessing, which
       // can cause another GC. Take into account the objects promoted during GC.
       old_generation_allocation_counter_ +=
-          static_cast<size_t>(promoted_objects_size_);
+          static_cast<size_t>(promoted_objects_size());
       old_generation_size_at_last_gc_ = PromotedSpaceSizeOfObjects();
     } else {
       Scavenge();
     }
 
     ProcessPretenuringFeedback();
   }
 
   UpdateSurvivalStatistics(start_new_space_size);
   ConfigureInitialOldGenerationSize();
@@ skipping 183 matching lines @@
   for (HeapObject* object = code_it.Next(); object != NULL;
        object = code_it.Next())
     object->Iterate(&v);
 }
 #endif  // VERIFY_HEAP
 
 
 void Heap::CheckNewSpaceExpansionCriteria() {
   if (FLAG_experimental_new_space_growth_heuristic) {
     if (new_space_.TotalCapacity() < new_space_.MaximumCapacity() &&
-        survived_last_scavenge_ * 100 / new_space_.TotalCapacity() >= 10) {
+        survived_last_scavenge() * 100 / new_space_.TotalCapacity() >= 10) {
       // Grow the size of new space if there is room to grow, and more than 10%
       // have survived the last scavenge.
       new_space_.Grow();
-      survived_since_last_expansion_ = 0;
+      survived_since_last_expansion_.SetValue(0);
     }
   } else if (new_space_.TotalCapacity() < new_space_.MaximumCapacity() &&
-             survived_since_last_expansion_ > new_space_.TotalCapacity()) {
+             survived_since_last_expansion() > new_space_.TotalCapacity()) {
     // Grow the size of new space if there is room to grow, and enough data
     // has survived scavenge since the last expansion.
     new_space_.Grow();
-    survived_since_last_expansion_ = 0;
+    survived_since_last_expansion_.SetValue(0);
   }
 }
 
 
 static bool IsUnscavengedHeapObject(Heap* heap, Object** p) {
   return heap->InNewSpace(*p) &&
          !HeapObject::cast(*p)->map_word().IsForwardingAddress();
 }
 
 
@@ skipping 216 matching lines @@
   ProcessYoungWeakReferences(&weak_object_retainer);
 
   DCHECK(new_space_front == new_space_.top());
 
   // Set age mark.
   new_space_.set_age_mark(new_space_.top());
 
   array_buffer_tracker()->FreeDead(true);
 
   // Update how much has survived scavenge.
-  IncrementYoungSurvivorsCounter(static_cast<int>(
-      (PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size()));
+  IncrementYoungSurvivorsCounter(
+      (PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size());
 
   LOG(isolate_, ResourceEvent("scavenge", "end"));
 
   gc_state_ = NOT_IN_GC;
 }
 
 
 String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
                                                                 Object** p) {
   MapWord first_word = HeapObject::cast(*p)->map_word();
@@ skipping 4461 matching lines @@
 }
 
 
 // static
 int Heap::GetStaticVisitorIdForMap(Map* map) {
   return StaticVisitorBase::GetVisitorId(map);
 }
 
 }  // namespace internal
 }  // namespace v8