clang-format runtime/vm

runtime/vm/heap.cc

 // Copyright (c) 2012, 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/heap.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
@@ skipping 21 matching lines @@
            intptr_t max_external_words)
     : isolate_(isolate),
       new_space_(this, max_new_gen_semi_words, kNewObjectAlignmentOffset),
       old_space_(this, max_old_gen_words, max_external_words),
       barrier_(new Monitor()),
       barrier_done_(new Monitor()),
       read_only_(false),
       gc_new_space_in_progress_(false),
       gc_old_space_in_progress_(false) {
   UpdateGlobalMaxUsed();
-  for (int sel = 0;
-       sel < kNumWeakSelectors;
-       sel++) {
+  for (int sel = 0; sel < kNumWeakSelectors; sel++) {
     new_weak_tables_[sel] = new WeakTable();
     old_weak_tables_[sel] = new WeakTable();
   }
   stats_.num_ = 0;
 }
 
 
 Heap::~Heap() {
   delete barrier_;
   delete barrier_done_;
 
-  for (int sel = 0;
-       sel < kNumWeakSelectors;
-       sel++) {
+  for (int sel = 0; sel < kNumWeakSelectors; sel++) {
     delete new_weak_tables_[sel];
     delete old_weak_tables_[sel];
   }
 }
 
 
 uword Heap::AllocateNew(intptr_t size) {
   ASSERT(Thread::Current()->no_safepoint_scope_depth() == 0);
   // Currently, only the Dart thread may allocate in new space.
   isolate()->AssertCurrentThreadIsMutator();
@@ skipping 63 matching lines @@
       while (old_space_.tasks() > 0) {
         ml.WaitWithSafepointCheck(thread);
       }
     }
   }
   addr = old_space_.TryAllocate(size, type, PageSpace::kForceGrowth);
   if (addr != 0) {
     return addr;
   }
   // Give up allocating this object.
-  OS::PrintErr(
-      "Exhausted heap space, trying to allocate %" Pd " bytes.\n", size);
+  OS::PrintErr("Exhausted heap space, trying to allocate %" Pd " bytes.\n",
+               size);
   return 0;
 }
 
 
 void Heap::AllocateExternal(intptr_t size, Space space) {
   ASSERT(Thread::Current()->no_safepoint_scope_depth() == 0);
   if (space == kNew) {
     isolate()->AssertCurrentThreadIsMutator();
     new_space_.AllocateExternal(size);
     if (new_space_.ExternalInWords() > (FLAG_new_gen_ext_limit * MBInWords)) {
@@ skipping 18 matching lines @@
     old_space_.FreeExternal(size);
   }
 }
 
 void Heap::PromoteExternal(intptr_t size) {
   new_space_.FreeExternal(size);
   old_space_.AllocateExternal(size);
 }
 
 bool Heap::Contains(uword addr) const {
-  return new_space_.Contains(addr) ||
-      old_space_.Contains(addr);
+  return new_space_.Contains(addr) || old_space_.Contains(addr);
 }
 
 
 bool Heap::NewContains(uword addr) const {
   return new_space_.Contains(addr);
 }
 
 
 bool Heap::OldContains(uword addr) const {
   return old_space_.Contains(addr);
@@ skipping 102 matching lines @@
     return raw_obj;
   }
   raw_obj = FindObjectInCodeSpace(visitor);
   return raw_obj;
 }
 
 
 bool Heap::BeginNewSpaceGC(Thread* thread) {
   MonitorLocker ml(&gc_in_progress_monitor_);
   bool start_gc_on_thread = true;
-  while (gc_new_space_in_progress_ ||
-         gc_old_space_in_progress_) {
+  while (gc_new_space_in_progress_ || gc_old_space_in_progress_) {
     start_gc_on_thread = !gc_new_space_in_progress_;
     ml.WaitWithSafepointCheck(thread);
   }
   if (start_gc_on_thread) {
     gc_new_space_in_progress_ = true;
     return true;
   }
   return false;
 }
 
 
 void Heap::EndNewSpaceGC() {
   MonitorLocker ml(&gc_in_progress_monitor_);
   ASSERT(gc_new_space_in_progress_);
   gc_new_space_in_progress_ = false;
   ml.NotifyAll();
 }
 
 
 bool Heap::BeginOldSpaceGC(Thread* thread) {
   MonitorLocker ml(&gc_in_progress_monitor_);
   bool start_gc_on_thread = true;
-  while (gc_new_space_in_progress_ ||
-         gc_old_space_in_progress_) {
+  while (gc_new_space_in_progress_ || gc_old_space_in_progress_) {
     start_gc_on_thread = !gc_old_space_in_progress_;
     ml.WaitWithSafepointCheck(thread);
   }
   if (start_gc_on_thread) {
     gc_old_space_in_progress_ = true;
     return true;
   }
   return false;
 }
 
@@ skipping 162 matching lines @@
     return OFFSET_OF(Heap, old_space_) + PageSpace::end_offset();
   }
 }
 
 
 void Heap::Init(Isolate* isolate,
                 intptr_t max_new_gen_words,
                 intptr_t max_old_gen_words,
                 intptr_t max_external_words) {
   ASSERT(isolate->heap() == NULL);
-  Heap* heap = new Heap(isolate,
-                        max_new_gen_words,
-                        max_old_gen_words,
+  Heap* heap = new Heap(isolate, max_new_gen_words, max_old_gen_words,
                         max_external_words);
   isolate->set_heap(heap);
 }
 
 
 void Heap::AddRegionsToObjectSet(ObjectSet* set) const {
   new_space_.AddRegionsToObjectSet(set);
   old_space_.AddRegionsToObjectSet(set);
 }
 
 
 ObjectSet* Heap::CreateAllocatedObjectSet(
     Zone* zone,
     MarkExpectation mark_expectation) const {
-  ObjectSet* allocated_set = new(zone) ObjectSet(zone);
+  ObjectSet* allocated_set = new (zone) ObjectSet(zone);
 
   this->AddRegionsToObjectSet(allocated_set);
   {
-    VerifyObjectVisitor object_visitor(
-        isolate(), allocated_set, mark_expectation);
+    VerifyObjectVisitor object_visitor(isolate(), allocated_set,
+                                       mark_expectation);
     this->VisitObjects(&object_visitor);
   }
 
   Isolate* vm_isolate = Dart::vm_isolate();
   vm_isolate->heap()->AddRegionsToObjectSet(allocated_set);
   {
     // VM isolate heap is premarked.
-    VerifyObjectVisitor vm_object_visitor(
-        isolate(), allocated_set, kRequireMarked);
+    VerifyObjectVisitor vm_object_visitor(isolate(), allocated_set,
+                                          kRequireMarked);
     vm_isolate->heap()->VisitObjects(&vm_object_visitor);
   }
 
   return allocated_set;
 }
 
 
 bool Heap::Verify(MarkExpectation mark_expectation) const {
   HeapIterationScope heap_iteration_scope;
   return VerifyGC(mark_expectation);
 }
 
 
 bool Heap::VerifyGC(MarkExpectation mark_expectation) const {
   StackZone stack_zone(Thread::Current());
-  ObjectSet* allocated_set = CreateAllocatedObjectSet(stack_zone.GetZone(),
-                                                      mark_expectation);
+  ObjectSet* allocated_set =
+      CreateAllocatedObjectSet(stack_zone.GetZone(), mark_expectation);
   VerifyPointersVisitor visitor(isolate(), allocated_set);
   VisitObjectPointers(&visitor);
 
   // Only returning a value so that Heap::Validate can be called from an ASSERT.
   return true;
 }
 
 
 void Heap::PrintSizes() const {
-  OS::PrintErr("New space (%" Pd64 "k of %" Pd64 "k) "
-               "Old space (%" Pd64 "k of %" Pd64 "k)\n",
-               (UsedInWords(kNew) / KBInWords),
-               (CapacityInWords(kNew) / KBInWords),
-               (UsedInWords(kOld) / KBInWords),
-               (CapacityInWords(kOld) / KBInWords));
+  OS::PrintErr(
+      "New space (%" Pd64 "k of %" Pd64
+      "k) "
+      "Old space (%" Pd64 "k of %" Pd64 "k)\n",
+      (UsedInWords(kNew) / KBInWords), (CapacityInWords(kNew) / KBInWords),
+      (UsedInWords(kOld) / KBInWords), (CapacityInWords(kOld) / KBInWords));
 }
 
 
 int64_t Heap::UsedInWords(Space space) const {
   return space == kNew ? new_space_.UsedInWords() : old_space_.UsedInWords();
 }
 
 
 int64_t Heap::CapacityInWords(Space space) const {
-  return space == kNew ? new_space_.CapacityInWords() :
-                         old_space_.CapacityInWords();
+  return space == kNew ? new_space_.CapacityInWords()
+                       : old_space_.CapacityInWords();
 }
 
 
 int64_t Heap::ExternalInWords(Space space) const {
-  return space == kNew ? new_space_.ExternalInWords() :
-                         old_space_.ExternalInWords();
+  return space == kNew ? new_space_.ExternalInWords()
+                       : old_space_.ExternalInWords();
 }
 
 
 int64_t Heap::GCTimeInMicros(Space space) const {
   if (space == kNew) {
     return new_space_.gc_time_micros();
   }
   return old_space_.gc_time_micros();
 }
 
@@ skipping 27 matching lines @@
 }
 
 
 int64_t Heap::PeerCount() const {
   return new_weak_tables_[kPeers]->count() + old_weak_tables_[kPeers]->count();
 }
 
 
 int64_t Heap::HashCount() const {
   return new_weak_tables_[kHashes]->count() +
-      old_weak_tables_[kHashes]->count();
+         old_weak_tables_[kHashes]->count();
 }
 
 
 int64_t Heap::ObjectIdCount() const {
   return new_weak_tables_[kObjectIds]->count() +
-      old_weak_tables_[kObjectIds]->count();
+         old_weak_tables_[kObjectIds]->count();
 }
 
 
 void Heap::ResetObjectIdTable() {
   new_weak_tables_[kObjectIds]->Reset();
   old_weak_tables_[kObjectIds]->Reset();
 }
 
 
 intptr_t Heap::GetWeakEntry(RawObject* raw_obj, WeakSelector sel) const {
@@ skipping 68 matching lines @@
   }
 #endif  // !PRODUCT
 }
 
 
 void Heap::PrintStats() {
   if (!FLAG_verbose_gc) return;
 
   if ((FLAG_verbose_gc_hdr != 0) &&
       (((stats_.num_ - 1) % FLAG_verbose_gc_hdr) == 0)) {
-    OS::PrintErr("[    GC    |  space  | count | start | gc time | "
-                 "new gen (KB) | old gen (KB) | timers | data ]\n"
-                 "[ (isolate)| (reason)|       |  (s)  |   (ms)  | "
-                 "used,cap,ext | used,cap,ext |  (ms)  |      ]\n");
+    OS::PrintErr(
+        "[    GC    |  space  | count | start | gc time | "
+        "new gen (KB) | old gen (KB) | timers | data ]\n"
+        "[ (isolate)| (reason)|       |  (s)  |   (ms)  | "
+        "used,cap,ext | used,cap,ext |  (ms)  |      ]\n");
   }
 
+  // clang-format off
   const char* space_str = stats_.space_ == kNew ? "Scavenge" : "Mark-Sweep";
   OS::PrintErr(
     "[ GC(%" Pd64 "): %s(%s), "  // GC(isolate), space(reason)
     "%" Pd ", "  // count
     "%.3f, "  // start time
     "%.3f, "  // total time
     "%" Pd ", %" Pd ", "  // new gen: in use before/after
     "%" Pd ", %" Pd ", "  // new gen: capacity before/after
     "%" Pd ", %" Pd ", "  // new gen: external before/after
     "%" Pd ", %" Pd ", "  // old gen: in use before/after
@@ skipping 20 matching lines @@
     RoundWordsToKB(stats_.before_.old_.external_in_words),
     RoundWordsToKB(stats_.after_.old_.external_in_words),
     MicrosecondsToMilliseconds(stats_.times_[0]),
     MicrosecondsToMilliseconds(stats_.times_[1]),
     MicrosecondsToMilliseconds(stats_.times_[2]),
     MicrosecondsToMilliseconds(stats_.times_[3]),
     stats_.data_[0],
     stats_.data_[1],
     stats_.data_[2],
     stats_.data_[3]);
+  // clang-format on
 }
 
 
 void Heap::PrintStatsToTimeline(TimelineEventScope* event) {
 #if !defined(PRODUCT)
   if ((event == NULL) || !event->enabled()) {
     return;
   }
   event->SetNumArguments(12);
-  event->FormatArgument(0,
-                        "Before.New.Used (kB)",
-                        "%" Pd "",
+  event->FormatArgument(0, "Before.New.Used (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.new_.used_in_words));
-  event->FormatArgument(1,
-                        "After.New.Used (kB)",
-                        "%" Pd "",
+  event->FormatArgument(1, "After.New.Used (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.new_.used_in_words));
-  event->FormatArgument(2,
-                        "Before.Old.Used (kB)",
-                        "%" Pd "",
+  event->FormatArgument(2, "Before.Old.Used (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.old_.used_in_words));
-  event->FormatArgument(3,
-                        "After.Old.Used (kB)",
-                        "%" Pd "",
+  event->FormatArgument(3, "After.Old.Used (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.old_.used_in_words));
 
-  event->FormatArgument(4,
-                        "Before.New.Capacity (kB)",
-                        "%" Pd "",
+  event->FormatArgument(4, "Before.New.Capacity (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.new_.capacity_in_words));
-  event->FormatArgument(5,
-                        "After.New.Capacity (kB)",
-                        "%" Pd "",
+  event->FormatArgument(5, "After.New.Capacity (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.new_.capacity_in_words));
-  event->FormatArgument(6,
-                        "Before.Old.Capacity (kB)",
-                        "%" Pd "",
+  event->FormatArgument(6, "Before.Old.Capacity (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.old_.capacity_in_words));
-  event->FormatArgument(7,
-                        "After.Old.Capacity (kB)",
-                        "%" Pd "",
+  event->FormatArgument(7, "After.Old.Capacity (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.old_.capacity_in_words));
 
-  event->FormatArgument(8,
-                        "Before.New.External (kB)",
-                        "%" Pd "",
+  event->FormatArgument(8, "Before.New.External (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.new_.external_in_words));
-  event->FormatArgument(9,
-                        "After.New.External (kB)",
-                        "%" Pd "",
+  event->FormatArgument(9, "After.New.External (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.new_.external_in_words));
-  event->FormatArgument(10,
-                        "Before.Old.External (kB)",
-                        "%" Pd "",
+  event->FormatArgument(10, "Before.Old.External (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.before_.old_.external_in_words));
-  event->FormatArgument(11,
-                        "After.Old.External (kB)",
-                        "%" Pd "",
+  event->FormatArgument(11, "After.Old.External (kB)", "%" Pd "",
                         RoundWordsToKB(stats_.after_.old_.external_in_words));
 #endif  // !defined(PRODUCT)
 }
 
 
 NoHeapGrowthControlScope::NoHeapGrowthControlScope()
     : StackResource(Thread::Current()) {
-    Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
-    current_growth_controller_state_ = heap->GrowthControlState();
-    heap->DisableGrowthControl();
+  Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
+  current_growth_controller_state_ = heap->GrowthControlState();
+  heap->DisableGrowthControl();
 }
 
 
 NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
-    Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
-    heap->SetGrowthControlState(current_growth_controller_state_);
+  Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
+  heap->SetGrowthControlState(current_growth_controller_state_);
 }
 
 
 WritableVMIsolateScope::WritableVMIsolateScope(Thread* thread)
     : StackResource(thread) {
   Dart::vm_isolate()->heap()->WriteProtect(false);
 }
 
 
 WritableVMIsolateScope::~WritableVMIsolateScope() {
   ASSERT(Dart::vm_isolate()->heap()->UsedInWords(Heap::kNew) == 0);
   Dart::vm_isolate()->heap()->WriteProtect(true);
 }
 
 }  // namespace dart