clang-format runtime/vm

runtime/vm/scavenger.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/scavenger.h"
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/object_set.h"
 #include "vm/object_id_ring.h"
 #include "vm/safepoint.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
 
 namespace dart {
 
-DEFINE_FLAG(int, early_tenuring_threshold, 66,
+DEFINE_FLAG(int,
+            early_tenuring_threshold,
+            66,
             "When more than this percentage of promotion candidates survive, "
             "promote all survivors of next scavenge.");
-DEFINE_FLAG(int, new_gen_garbage_threshold, 90,
+DEFINE_FLAG(int,
+            new_gen_garbage_threshold,
+            90,
             "Grow new gen when less than this percentage is garbage.");
 DEFINE_FLAG(int, new_gen_growth_factor, 4, "Grow new gen by this factor.");
 
 // Scavenger uses RawObject::kMarkBit to distinguish forwaded and non-forwarded
 // objects. The kMarkBit does not intersect with the target address because of
 // object alignment.
 enum {
   kForwardingMask = 1 << RawObject::kMarkBit,
   kNotForwarded = 0,
   kForwarded = kForwardingMask,
@@ skipping 26 matching lines @@
                             Scavenger* scavenger,
                             SemiSpace* from)
       : ObjectPointerVisitor(isolate),
         thread_(Thread::Current()),
         scavenger_(scavenger),
         from_(from),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
         page_space_(scavenger->heap_->old_space()),
         bytes_promoted_(0),
-        visiting_old_object_(NULL) { }
+        visiting_old_object_(NULL) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     ASSERT((visiting_old_object_ != NULL) ||
            scavenger_->Contains(reinterpret_cast<uword>(first)) ||
            !heap_->Contains(reinterpret_cast<uword>(first)));
     for (RawObject** current = first; current <= last; current++) {
       ScavengePointer(current);
     }
   }
 
@@ skipping 66 matching lines @@
           // Promotion did not succeed. Copy into the to space instead.
           new_addr = scavenger_->TryAllocate(size);
           NOT_IN_PRODUCT(class_table->UpdateLiveNew(cid, size));
         }
       }
       // During a scavenge we always succeed to at least copy all of the
       // current objects to the to space.
       ASSERT(new_addr != 0);
       // Copy the object to the new location.
       memmove(reinterpret_cast<void*>(new_addr),
-              reinterpret_cast<void*>(raw_addr),
-              size);
+              reinterpret_cast<void*>(raw_addr), size);
       // Remember forwarding address.
       ForwardTo(raw_addr, new_addr);
     }
     // Update the reference.
     RawObject* new_obj = RawObject::FromAddr(new_addr);
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_object_ != NULL) {
       UpdateStoreBuffer(p, new_obj);
     }
@@ skipping 12 matching lines @@
   friend class Scavenger;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
   ScavengerWeakVisitor(Thread* thread,
                        Scavenger* scavenger,
-                       FinalizationQueue* finalization_queue) :
-      HandleVisitor(thread),
-      scavenger_(scavenger),
-      queue_(finalization_queue) {
+                       FinalizationQueue* finalization_queue)
+      : HandleVisitor(thread),
+        scavenger_(scavenger),
+        queue_(finalization_queue) {
     ASSERT(scavenger->heap_->isolate() == thread->isolate());
   }
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
-      reinterpret_cast<FinalizablePersistentHandle*>(addr);
+        reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject** p = handle->raw_addr();
     if (scavenger_->IsUnreachable(p)) {
       handle->UpdateUnreachable(thread()->isolate(), queue_);
     } else {
       handle->UpdateRelocated(thread()->isolate());
     }
   }
 
  private:
   Scavenger* scavenger_;
   FinalizationQueue* queue_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
 };
 
 
 // Visitor used to verify that all old->new references have been added to the
 // StoreBuffers.
 class VerifyStoreBufferPointerVisitor : public ObjectPointerVisitor {
  public:
-  VerifyStoreBufferPointerVisitor(Isolate* isolate,
-                                  const SemiSpace* to)
+  VerifyStoreBufferPointerVisitor(Isolate* isolate, const SemiSpace* to)
       : ObjectPointerVisitor(isolate), to_(to) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       RawObject* obj = *current;
       if (obj->IsHeapObject() && obj->IsNewObject()) {
         ASSERT(to_->Contains(RawObject::ToAddr(obj)));
       }
     }
   }
 
  private:
   const SemiSpace* to_;
 
   DISALLOW_COPY_AND_ASSIGN(VerifyStoreBufferPointerVisitor);
 };
 
 
 SemiSpace::SemiSpace(VirtualMemory* reserved)
     : reserved_(reserved), region_(NULL, 0) {
   if (reserved != NULL) {
     region_ = MemoryRegion(reserved_->address(), reserved_->size());
   }
 }
 
 
 SemiSpace::~SemiSpace() {
   if (reserved_ != NULL) {
 #if defined(DEBUG)
-    memset(reserved_->address(), Heap::kZapByte,
-           size_in_words() << kWordSizeLog2);
+    memset(reserved_->address(), Heap::kZapByte, size_in_words()
+                                                     << kWordSizeLog2);
 #endif  // defined(DEBUG)
     delete reserved_;
   }
 }
 
 
 Mutex* SemiSpace::mutex_ = NULL;
 SemiSpace* SemiSpace::cache_ = NULL;
 
 
@@ skipping 44 matching lines @@
     MutexLocker locker(mutex_);
     old_cache = cache_;
     cache_ = this;
   }
   delete old_cache;
 }
 
 
 void SemiSpace::WriteProtect(bool read_only) {
   if (reserved_ != NULL) {
-    bool success = reserved_->Protect(
-        read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
+    bool success = reserved_->Protect(read_only ? VirtualMemory::kReadOnly
+                                                : VirtualMemory::kReadWrite);
     ASSERT(success);
   }
 }
 
 
 Scavenger::Scavenger(Heap* heap,
                      intptr_t max_semi_capacity_in_words,
                      uword object_alignment)
     : heap_(heap),
       max_semi_capacity_in_words_(max_semi_capacity_in_words),
       object_alignment_(object_alignment),
       scavenging_(false),
       delayed_weak_properties_(NULL),
       gc_time_micros_(0),
       collections_(0),
       external_size_(0) {
   // Verify assumptions about the first word in objects which the scavenger is
   // going to use for forwarding pointers.
   ASSERT(Object::tags_offset() == 0);
 
   // Set initial size resulting in a total of three different levels.
-  const intptr_t initial_semi_capacity_in_words = max_semi_capacity_in_words /
+  const intptr_t initial_semi_capacity_in_words =
+      max_semi_capacity_in_words /
       (FLAG_new_gen_growth_factor * FLAG_new_gen_growth_factor);
   to_ = SemiSpace::New(initial_semi_capacity_in_words);
   if (to_ == NULL) {
     OUT_OF_MEMORY();
   }
   // Setup local fields.
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 
@@ skipping 179 matching lines @@
 }
 
 
 void Scavenger::IterateWeakRoots(Isolate* isolate, HandleVisitor* visitor) {
   isolate->VisitWeakPersistentHandles(visitor);
 }
 
 
 void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
   // Iterate until all work has been drained.
-  while ((resolved_top_ < top_) ||
-         PromotedStackHasMore()) {
+  while ((resolved_top_ < top_) || PromotedStackHasMore()) {
     while (resolved_top_ < top_) {
       RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
       intptr_t class_id = raw_obj->GetClassId();
       if (class_id != kWeakPropertyCid) {
         resolved_top_ += raw_obj->VisitPointers(visitor);
       } else {
         RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
         resolved_top_ += ProcessWeakProperty(raw_weak, visitor);
       }
     }
@@ skipping 48 matching lines @@
 
 void Scavenger::UpdateMaxHeapCapacity() {
   if (heap_ == NULL) {
     // Some unit tests.
     return;
   }
   ASSERT(to_ != NULL);
   ASSERT(heap_ != NULL);
   Isolate* isolate = heap_->isolate();
   ASSERT(isolate != NULL);
-  isolate->GetHeapNewCapacityMaxMetric()->SetValue(
-      to_->size_in_words() * kWordSize);
+  isolate->GetHeapNewCapacityMaxMetric()->SetValue(to_->size_in_words() *
+                                                   kWordSize);
 }
 
 
 void Scavenger::UpdateMaxHeapUsage() {
   if (heap_ == NULL) {
     // Some unit tests.
     return;
   }
   ASSERT(to_ != NULL);
   ASSERT(heap_ != NULL);
   Isolate* isolate = heap_->isolate();
   ASSERT(isolate != NULL);
   isolate->GetHeapNewUsedMaxMetric()->SetValue(UsedInWords() * kWordSize);
 }
 
 
 void Scavenger::EnqueueWeakProperty(RawWeakProperty* raw_weak) {
   ASSERT(raw_weak->IsHeapObject());
   ASSERT(raw_weak->IsNewObject());
   ASSERT(raw_weak->IsWeakProperty());
-  DEBUG_ONLY(
-      uword raw_addr = RawObject::ToAddr(raw_weak);
-      uword header = *reinterpret_cast<uword*>(raw_addr);
-      ASSERT(!IsForwarding(header));
-  )
+#if defined(DEBUG)
+  uword raw_addr = RawObject::ToAddr(raw_weak);
+  uword header = *reinterpret_cast<uword*>(raw_addr);
+  ASSERT(!IsForwarding(header));
+#endif  // defined(DEBUG)
   ASSERT(raw_weak->ptr()->next_ == 0);
   raw_weak->ptr()->next_ = reinterpret_cast<uword>(delayed_weak_properties_);
   delayed_weak_properties_ = raw_weak;
 }
 
 
 uword Scavenger::ProcessWeakProperty(RawWeakProperty* raw_weak,
                                      ScavengerVisitor* visitor) {
   // The fate of the weak property is determined by its key.
   RawObject* raw_key = raw_weak->ptr()->key_;
   if (raw_key->IsHeapObject() && raw_key->IsNewObject()) {
     uword raw_addr = RawObject::ToAddr(raw_key);
     uword header = *reinterpret_cast<uword*>(raw_addr);
     if (!IsForwarding(header)) {
       // Key is white.  Enqueue the weak property.
       EnqueueWeakProperty(raw_weak);
       return raw_weak->Size();
     }
   }
   // Key is gray or black.  Make the weak property black.
   return raw_weak->VisitPointers(visitor);
 }
 
 
 void Scavenger::ProcessWeakReferences() {
   // Rehash the weak tables now that we know which objects survive this cycle.
-  for (int sel = 0;
-       sel < Heap::kNumWeakSelectors;
-       sel++) {
-    WeakTable* table = heap_->GetWeakTable(
-        Heap::kNew, static_cast<Heap::WeakSelector>(sel));
-    heap_->SetWeakTable(Heap::kNew,
-                        static_cast<Heap::WeakSelector>(sel),
+  for (int sel = 0; sel < Heap::kNumWeakSelectors; sel++) {
+    WeakTable* table =
+        heap_->GetWeakTable(Heap::kNew, static_cast<Heap::WeakSelector>(sel));
+    heap_->SetWeakTable(Heap::kNew, static_cast<Heap::WeakSelector>(sel),
                         WeakTable::NewFrom(table));
     intptr_t size = table->size();
     for (intptr_t i = 0; i < size; i++) {
       if (table->IsValidEntryAt(i)) {
         RawObject* raw_obj = table->ObjectAt(i);
         ASSERT(raw_obj->IsHeapObject());
         uword raw_addr = RawObject::ToAddr(raw_obj);
         uword header = *reinterpret_cast<uword*>(raw_addr);
         if (IsForwarding(header)) {
           // The object has survived.  Preserve its record.
           uword new_addr = ForwardedAddr(header);
           raw_obj = RawObject::FromAddr(new_addr);
-          heap_->SetWeakEntry(raw_obj,
-                              static_cast<Heap::WeakSelector>(sel),
+          heap_->SetWeakEntry(raw_obj, static_cast<Heap::WeakSelector>(sel),
                               table->ValueAt(i));
         }
       }
     }
     // Remove the old table as it has been replaced with the newly allocated
     // table above.
     delete table;
   }
 
   // The queued weak properties at this point do not refer to reachable keys,
   // so we clear their key and value fields.
   {
     RawWeakProperty* cur_weak = delayed_weak_properties_;
     delayed_weak_properties_ = NULL;
     while (cur_weak != NULL) {
       uword next_weak = cur_weak->ptr()->next_;
       // Reset the next pointer in the weak property.
       cur_weak->ptr()->next_ = 0;
 
-      DEBUG_ONLY(
-          RawObject* raw_key = cur_weak->ptr()->key_;
-          uword raw_addr = RawObject::ToAddr(raw_key);
-          uword header = *reinterpret_cast<uword*>(raw_addr);
-          ASSERT(!IsForwarding(header));
-          ASSERT(raw_key->IsHeapObject());
-          ASSERT(raw_key->IsNewObject());  // Key still points into from space.
-      )
+#if defined(DEBUG)
+      RawObject* raw_key = cur_weak->ptr()->key_;
+      uword raw_addr = RawObject::ToAddr(raw_key);
+      uword header = *reinterpret_cast<uword*>(raw_addr);
+      ASSERT(!IsForwarding(header));
+      ASSERT(raw_key->IsHeapObject());
+      ASSERT(raw_key->IsNewObject());  // Key still points into from space.
+#endif                                 // defined(DEBUG)
 
       WeakProperty::Clear(cur_weak);
 
       // Advance to next weak property in the queue.
       cur_weak = reinterpret_cast<RawWeakProperty*>(next_weak);
     }
   }
 }
 
 
@@ skipping 102 matching lines @@
         IterateWeakRoots(isolate, &weak_visitor);
       }
     }
     ProcessWeakReferences();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentTimeMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
-    stats_history_.Add(
-        ScavengeStats(start, end,
-                      usage_before, GetCurrentUsage(),
-                      promo_candidate_words,
-                      visitor.bytes_promoted() >> kWordSizeLog2));
+    stats_history_.Add(ScavengeStats(
+        start, end, usage_before, GetCurrentUsage(), promo_candidate_words,
+        visitor.bytes_promoted() >> kWordSizeLog2));
   }
   Epilogue(isolate, from, invoke_api_callbacks);
 
   // TODO(koda): Make verification more compatible with concurrent sweep.
   if (FLAG_verify_after_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying after Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
@@ skipping 46 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart