VM: Re-format to use at most one newline between functions

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/object_id_ring.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 DetachCode() {
@@ skipping 47 matching lines @@
     skipped_code_functions_.Clear();
 #endif  // !DART_PRECOMPILED_RUNTIME
   }
 
  private:
   GrowableArray<RawFunction*> skipped_code_functions_;
 
   DISALLOW_COPY_AND_ASSIGN(SkippedCodeFunctions);
 };
 
-
 class MarkerWorkList : public ValueObject {
  public:
   explicit MarkerWorkList(MarkingStack* marking_stack)
       : marking_stack_(marking_stack) {
     work_ = marking_stack_->PopEmptyBlock();
   }
 
   ~MarkerWorkList() {
     ASSERT(work_ == NULL);
     ASSERT(marking_stack_ == NULL);
@@ skipping 31 matching lines @@
     work_ = NULL;
     // Fail fast on attempts to mark after finalizing.
     marking_stack_ = NULL;
   }
 
  private:
   MarkingStack::Block* work_;
   MarkingStack* marking_stack_;
 };
 
-
 template <bool sync>
 class MarkingVisitorBase : public ObjectPointerVisitor {
  public:
   MarkingVisitorBase(Isolate* isolate,
                      PageSpace* page_space,
                      MarkingStack* marking_stack,
                      SkippedCodeFunctions* skipped_code_functions)
       : ObjectPointerVisitor(isolate),
         thread_(Thread::Current()),
 #ifndef PRODUCT
@@ skipping 258 matching lines @@
   PageSpace* page_space_;
   MarkerWorkList work_list_;
   RawWeakProperty* delayed_weak_properties_;
   RawObject* visiting_old_object_;
   SkippedCodeFunctions* skipped_code_functions_;
   uintptr_t marked_bytes_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitorBase);
 };
 
-
 typedef MarkingVisitorBase<false> UnsyncMarkingVisitor;
 typedef MarkingVisitorBase<true> SyncMarkingVisitor;
 
-
 static bool IsUnreachable(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   if (raw_obj == Object::null()) {
     return true;
   }
   if (!raw_obj->IsOldObject()) {
     return false;
   }
   return !raw_obj->IsMarked();
 }
 
-
 class MarkingWeakVisitor : public HandleVisitor {
  public:
   explicit MarkingWeakVisitor(Thread* thread) : HandleVisitor(thread) {}
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject* raw_obj = handle->raw();
     if (IsUnreachable(raw_obj)) {
       handle->UpdateUnreachable(thread()->isolate());
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MarkingWeakVisitor);
 };
 
-
 void GCMarker::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
   isolate->PrepareForGC();
   // The store buffers will be rebuilt as part of marking, reset them now.
   isolate->store_buffer()->Reset();
 }
 
-
 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) {
   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));
     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) {}
 
-
   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();
       }
     }
   }
 };
 
-
 void GCMarker::ProcessObjectIdTable(Isolate* isolate) {
 #ifndef PRODUCT
   if (!FLAG_support_service) {
     return;
   }
   ObjectIdRingClearPointerVisitor visitor(isolate);
   ObjectIdRing* ring = isolate->object_id_ring();
   ASSERT(ring != NULL);
   ring->VisitPointers(&visitor);
 #endif  // !PRODUCT
 }
 
-
 class MarkTask : public ThreadPool::Task {
  public:
   MarkTask(GCMarker* marker,
            Isolate* isolate,
            Heap* heap,
            PageSpace* page_space,
            MarkingStack* marking_stack,
            ThreadBarrier* barrier,
            bool collect_code,
            intptr_t task_index,
@@ skipping 103 matching lines @@
   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>
 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);
       if (count > 0) {
         const intptr_t size = visitor->live_size(i);
         table->UpdateLiveOld(i, size, count);
       }
     }
 #endif  // !PRODUCT
   }
   visitor->Finalize();
 }
 
-
 void GCMarker::MarkObjects(Isolate* isolate,
                            PageSpace* page_space,
                            bool invoke_api_callbacks,
                            bool collect_code) {
   Prologue(isolate, invoke_api_callbacks);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
@@ skipping 61 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