clang-format runtime/vm

runtime/vm/gc_marker.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/gc_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/thread_barrier.h"
 #include "vm/thread_pool.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/visitor.h"
 #include "vm/object_id_ring.h"
 
 namespace dart {
 
 class SkippedCodeFunctions : public ZoneAllocated {
  public:
   SkippedCodeFunctions() {}
 
-  void Add(RawFunction* func) {
-    skipped_code_functions_.Add(func);
-  }
+  void Add(RawFunction* func) { skipped_code_functions_.Add(func); }
 
   void DetachCode() {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
 #else
     intptr_t unoptimized_code_count = 0;
     intptr_t current_code_count = 0;
     for (int i = 0; i < skipped_code_functions_.length(); i++) {
       RawFunction* func = skipped_code_functions_[i];
       RawCode* code = func->ptr()->code_;
       if (!code->IsMarked()) {
         // If the code wasn't strongly visited through other references
         // after skipping the function's code pointer, then we disconnect the
         // code from the function.
-        func->StorePointer(
-            &(func->ptr()->code_),
-            StubCode::LazyCompile_entry()->code());
+        func->StorePointer(&(func->ptr()->code_),
+                           StubCode::LazyCompile_entry()->code());
         uword entry_point = StubCode::LazyCompile_entry()->EntryPoint();
         func->ptr()->entry_point_ = entry_point;
         if (FLAG_log_code_drop) {
           // NOTE: This code runs while GC is in progress and runs within
           // a NoHandleScope block. Hence it is not okay to use a regular Zone
           // or Scope handle. We use a direct stack handle so the raw pointer in
           // this handle is not traversed. The use of a handle is mainly to
           // be able to reuse the handle based code and avoid having to add
           // helper functions to the raw object interface.
           String name;
@@ skipping 76 matching lines @@
     // Fail fast on attempts to mark after finalizing.
     marking_stack_ = NULL;
   }
 
  private:
   MarkingStack::Block* work_;
   MarkingStack* marking_stack_;
 };
 
 
-template<bool sync>
+template <bool sync>
 class MarkingVisitorBase : public ObjectPointerVisitor {
  public:
   MarkingVisitorBase(Isolate* isolate,
-                 Heap* heap,
-                 PageSpace* page_space,
-                 MarkingStack* marking_stack,
-                 SkippedCodeFunctions* skipped_code_functions)
+                     Heap* heap,
+                     PageSpace* page_space,
+                     MarkingStack* marking_stack,
+                     SkippedCodeFunctions* skipped_code_functions)
       : ObjectPointerVisitor(isolate),
         thread_(Thread::Current()),
         heap_(heap),
         vm_heap_(Dart::vm_isolate()->heap()),
         class_stats_count_(isolate->class_table()->NumCids()),
         class_stats_size_(isolate->class_table()->NumCids()),
         page_space_(page_space),
         work_list_(marking_stack),
         delayed_weak_properties_(NULL),
         visiting_old_object_(NULL),
         skipped_code_functions_(skipped_code_functions),
         marked_bytes_(0) {
     ASSERT(heap_ != vm_heap_);
     ASSERT(thread_->isolate() == isolate);
     class_stats_count_.SetLength(isolate->class_table()->NumCids());
     class_stats_size_.SetLength(isolate->class_table()->NumCids());
     for (intptr_t i = 0; i < class_stats_count_.length(); ++i) {
       class_stats_count_[i] = 0;
       class_stats_size_[i] = 0;
     }
   }
 
   uintptr_t marked_bytes() const { return marked_bytes_; }
 
   intptr_t live_count(intptr_t class_id) {
     return class_stats_count_[class_id];
   }
 
-  intptr_t live_size(intptr_t class_id) {
-    return class_stats_size_[class_id];
-  }
+  intptr_t live_size(intptr_t class_id) { return class_stats_size_[class_id]; }
 
   bool ProcessPendingWeakProperties() {
     bool marked = false;
     RawWeakProperty* cur_weak = delayed_weak_properties_;
     delayed_weak_properties_ = NULL;
     while (cur_weak != NULL) {
       uword next_weak = cur_weak->ptr()->next_;
       RawObject* raw_key = cur_weak->ptr()->key_;
       // Reset the next pointer in the weak property.
       cur_weak->ptr()->next_ = 0;
@@ skipping 50 matching lines @@
     } while (raw_obj != NULL);
     VisitingOldObject(NULL);
   }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current, current);
     }
   }
 
-  bool visit_function_code() const {
-    return skipped_code_functions_ == NULL;
-  }
+  bool visit_function_code() const { return skipped_code_functions_ == NULL; }
 
   virtual void add_skipped_code_function(RawFunction* func) {
     ASSERT(!visit_function_code());
     skipped_code_functions_->Add(func);
   }
 
   void EnqueueWeakProperty(RawWeakProperty* raw_weak) {
     ASSERT(raw_weak->IsHeapObject());
     ASSERT(raw_weak->IsOldObject());
     ASSERT(raw_weak->IsWeakProperty());
     ASSERT(raw_weak->IsMarked());
     ASSERT(raw_weak->ptr()->next_ == 0);
     raw_weak->ptr()->next_ = reinterpret_cast<uword>(delayed_weak_properties_);
     delayed_weak_properties_ = raw_weak;
   }
 
   intptr_t ProcessWeakProperty(RawWeakProperty* raw_weak) {
     // The fate of the weak property is determined by its key.
     RawObject* raw_key = raw_weak->ptr()->key_;
-    if (raw_key->IsHeapObject() &&
-        raw_key->IsOldObject() &&
+    if (raw_key->IsHeapObject() && raw_key->IsOldObject() &&
         !raw_key->IsMarked()) {
       // Key was 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(this);
   }
 
   // Called when all marking is complete.
@@ skipping 19 matching lines @@
   }
 
   void VisitingOldObject(RawObject* obj) {
     ASSERT((obj == NULL) || obj->IsOldObject());
     visiting_old_object_ = obj;
   }
 
  private:
   void PushMarked(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
-    ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc) ?
-           page_space_->Contains(RawObject::ToAddr(raw_obj)) :
-           true);
+    ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc)
+               ? page_space_->Contains(RawObject::ToAddr(raw_obj))
+               : true);
 
     // Push the marked object on the marking stack.
     ASSERT(raw_obj->IsMarked());
     // We acquired the mark bit => no other task is modifying the header.
     // TODO(koda): For concurrent mutator, this needs synchronization. Consider
     // clearing these bits already in the CAS for the mark bit.
     raw_obj->ClearRememberedBitUnsynchronized();
     work_list_.Push(raw_obj);
   }
 
@@ skipping 102 matching lines @@
   }
   if (!raw_obj->IsOldObject()) {
     return false;
   }
   return !raw_obj->IsMarked();
 }
 
 
 class MarkingWeakVisitor : public HandleVisitor {
  public:
-  MarkingWeakVisitor(Thread* thread, FinalizationQueue* queue) :
-      HandleVisitor(thread), queue_(queue) { }
+  MarkingWeakVisitor(Thread* thread, FinalizationQueue* queue)
+      : HandleVisitor(thread), queue_(queue) {}
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject* raw_obj = handle->raw();
     if (IsUnreachable(raw_obj)) {
       handle->UpdateUnreachable(thread()->isolate(), queue_);
     }
   }
 
@@ skipping 16 matching lines @@
 
 void GCMarker::Epilogue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
     (isolate->gc_epilogue_callback())();
   }
 }
 
 
 void GCMarker::IterateRoots(Isolate* isolate,
                             ObjectPointerVisitor* visitor,
-                            intptr_t slice_index, intptr_t num_slices) {
+                            intptr_t slice_index,
+                            intptr_t num_slices) {
   ASSERT(0 <= slice_index && slice_index < num_slices);
   if ((slice_index == 0) || (num_slices <= 1)) {
     isolate->VisitObjectPointers(visitor,
                                  StackFrameIterator::kDontValidateFrames);
   }
   if ((slice_index == 1) || (num_slices <= 1)) {
     heap_->new_space()->VisitObjectPointers(visitor);
   }
 
   // For now, we just distinguish two parts of the root set, so any remaining
   // slices are empty.
 }
 
 
 void GCMarker::IterateWeakRoots(Isolate* isolate, HandleVisitor* visitor) {
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   isolate->VisitWeakPersistentHandles(visitor);
 }
 
 
 void GCMarker::ProcessWeakTables(PageSpace* page_space) {
-  for (int sel = 0;
-       sel < Heap::kNumWeakSelectors;
-       sel++) {
-    WeakTable* table = heap_->GetWeakTable(
-        Heap::kOld, static_cast<Heap::WeakSelector>(sel));
+  for (int sel = 0; sel < Heap::kNumWeakSelectors; sel++) {
+    WeakTable* table =
+        heap_->GetWeakTable(Heap::kOld, static_cast<Heap::WeakSelector>(sel));
     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());
         if (!raw_obj->IsMarked()) {
           table->InvalidateAt(i);
         }
       }
     }
   }
 }
 
 
 class ObjectIdRingClearPointerVisitor : public ObjectPointerVisitor {
  public:
-  explicit ObjectIdRingClearPointerVisitor(Isolate* isolate) :
-      ObjectPointerVisitor(isolate) {}
+  explicit ObjectIdRingClearPointerVisitor(Isolate* isolate)
+      : ObjectPointerVisitor(isolate) {}
 
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       RawObject* raw_obj = *current;
       ASSERT(raw_obj->IsHeapObject());
       if (raw_obj->IsOldObject() && !raw_obj->IsMarked()) {
         // Object has become garbage. Replace it will null.
         *current = Object::null();
       }
@@ skipping 29 matching lines @@
            uintptr_t* num_busy)
       : marker_(marker),
         isolate_(isolate),
         heap_(heap),
         page_space_(page_space),
         marking_stack_(marking_stack),
         barrier_(barrier),
         collect_code_(collect_code),
         task_index_(task_index),
         num_tasks_(num_tasks),
-        num_busy_(num_busy) {
-  }
+        num_busy_(num_busy) {}
 
   virtual void Run() {
     bool result =
         Thread::EnterIsolateAsHelper(isolate_, Thread::kMarkerTask, true);
     ASSERT(result);
     {
       Thread* thread = Thread::Current();
       TIMELINE_FUNCTION_GC_DURATION(thread, "MarkTask");
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       SkippedCodeFunctions* skipped_code_functions =
-          collect_code_ ? new(zone) SkippedCodeFunctions() : NULL;
+          collect_code_ ? new (zone) SkippedCodeFunctions() : NULL;
       SyncMarkingVisitor visitor(isolate_, heap_, page_space_, marking_stack_,
                                  skipped_code_functions);
       // Phase 1: Iterate over roots and drain marking stack in tasks.
       marker_->IterateRoots(isolate_, &visitor, task_index_, num_tasks_);
 
       bool more_to_mark = false;
       do {
         do {
           visitor.DrainMarkingStack();
 
@@ skipping 43 matching lines @@
           more_to_mark = true;
         }
         barrier_->Sync();
       } while (more_to_mark);
 
       // Phase 2: Weak processing and follow-up marking on main thread.
       barrier_->Sync();
 
       // Phase 3: Finalize results from all markers (detach code, etc.).
       if (FLAG_log_marker_tasks) {
-        THR_Print("Task %" Pd " marked %" Pd " bytes.\n",
-                  task_index_, visitor.marked_bytes());
+        THR_Print("Task %" Pd " marked %" Pd " bytes.\n", task_index_,
+                  visitor.marked_bytes());
       }
       marker_->FinalizeResultsFrom(&visitor);
     }
     Thread::ExitIsolateAsHelper(true);
 
     // This task is done. Notify the original thread.
     barrier_->Exit();
   }
 
  private:
   GCMarker* marker_;
   Isolate* isolate_;
   Heap* heap_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
   ThreadBarrier* barrier_;
   bool collect_code_;
   const intptr_t task_index_;
   const intptr_t num_tasks_;
   uintptr_t* num_busy_;
 
   DISALLOW_COPY_AND_ASSIGN(MarkTask);
 };
 
 
-template<class MarkingVisitorType>
+template <class MarkingVisitorType>
 void GCMarker::FinalizeResultsFrom(MarkingVisitorType* visitor) {
   {
     MutexLocker ml(&stats_mutex_);
     marked_bytes_ += visitor->marked_bytes();
 #ifndef PRODUCT
     // Class heap stats are not themselves thread-safe yet, so we update the
     // stats while holding stats_mutex_.
     ClassTable* table = heap_->isolate()->class_table();
     for (intptr_t i = 0; i < table->NumCids(); ++i) {
       const intptr_t count = visitor->live_count(i);
@@ skipping 18 matching lines @@
   {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     MarkingStack marking_stack;
     marked_bytes_ = 0;
     const int num_tasks = FLAG_marker_tasks;
     if (num_tasks == 0) {
       // Mark everything on main thread.
       SkippedCodeFunctions* skipped_code_functions =
-          collect_code ? new(zone) SkippedCodeFunctions() : NULL;
+          collect_code ? new (zone) SkippedCodeFunctions() : NULL;
       UnsyncMarkingVisitor mark(isolate, heap_, page_space, &marking_stack,
                                 skipped_code_functions);
       IterateRoots(isolate, &mark, 0, 1);
       mark.DrainMarkingStack();
       {
         TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
         if (FLAG_background_finalization) {
           FinalizationQueue* queue = new FinalizationQueue();
           MarkingWeakVisitor mark_weak(thread, queue);
           IterateWeakRoots(isolate, &mark_weak);
           if (queue->length() > 0) {
             Dart::thread_pool()->Run(new BackgroundFinalizer(isolate, queue));
           } else {
             delete queue;
           }
         } else {
           MarkingWeakVisitor mark_weak(thread, NULL);
           IterateWeakRoots(isolate, &mark_weak);
         }
       }
       // All marking done; detach code, etc.
       FinalizeResultsFrom(&mark);
     } else {
-      ThreadBarrier barrier(num_tasks + 1,
-                            heap_->barrier(),
+      ThreadBarrier barrier(num_tasks + 1, heap_->barrier(),
                             heap_->barrier_done());
       // Used to coordinate draining among tasks; all start out as 'busy'.
       uintptr_t num_busy = num_tasks;
       // Phase 1: Iterate over roots and drain marking stack in tasks.
       for (intptr_t i = 0; i < num_tasks; ++i) {
         MarkTask* mark_task =
             new MarkTask(this, isolate, heap_, page_space, &marking_stack,
-                         &barrier, collect_code,
-                         i, num_tasks, &num_busy);
+                         &barrier, collect_code, i, num_tasks, &num_busy);
         ThreadPool* pool = Dart::thread_pool();
         pool->Run(mark_task);
       }
       bool more_to_mark = false;
       do {
         // Wait for all markers to stop.
         barrier.Sync();
 #if defined(DEBUG)
         ASSERT(AtomicOperations::LoadRelaxed(&num_busy) == 0);
         // Caveat: must not allow any marker to continue past the barrier
@@ skipping 33 matching lines @@
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart