clang-format runtime/vm

runtime/vm/scavenger.h

 // 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.
 
 #ifndef RUNTIME_VM_SCAVENGER_H_
 #define RUNTIME_VM_SCAVENGER_H_
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/dart.h"
@@ skipping 53 matching lines @@
 
 // Statistics for a particular scavenge.
 class ScavengeStats {
  public:
   ScavengeStats() {}
   ScavengeStats(int64_t start_micros,
                 int64_t end_micros,
                 SpaceUsage before,
                 SpaceUsage after,
                 intptr_t promo_candidates_in_words,
-                intptr_t promoted_in_words) :
-      start_micros_(start_micros),
-      end_micros_(end_micros),
-      before_(before),
-      after_(after),
-      promo_candidates_in_words_(promo_candidates_in_words),
-      promoted_in_words_(promoted_in_words) {}
+                intptr_t promoted_in_words)
+      : start_micros_(start_micros),
+        end_micros_(end_micros),
+        before_(before),
+        after_(after),
+        promo_candidates_in_words_(promo_candidates_in_words),
+        promoted_in_words_(promoted_in_words) {}
 
   // Of all data before scavenge, what fraction was found to be garbage?
   double GarbageFraction() const {
     intptr_t survived = after_.used_in_words + promoted_in_words_;
     return 1.0 - (survived / static_cast<double>(before_.used_in_words));
   }
 
   // Fraction of promotion candidates that survived and was thereby promoted.
   // Returns zero if there were no promotion candidates.
   double PromoCandidatesSuccessFraction() const {
-    return promo_candidates_in_words_ > 0 ?
-        promoted_in_words_ / static_cast<double>(promo_candidates_in_words_) :
-        0.0;
+    return promo_candidates_in_words_ > 0
+               ? promoted_in_words_ /
+                     static_cast<double>(promo_candidates_in_words_)
+               : 0.0;
   }
 
-  int64_t DurationMicros() const {
-    return end_micros_ - start_micros_;
-  }
+  int64_t DurationMicros() const { return end_micros_ - start_micros_; }
 
  private:
   int64_t start_micros_;
   int64_t end_micros_;
   SpaceUsage before_;
   SpaceUsage after_;
   intptr_t promo_candidates_in_words_;
   intptr_t promoted_in_words_;
 };
 
 
 class Scavenger {
  public:
   Scavenger(Heap* heap,
             intptr_t max_semi_capacity_in_words,
             uword object_alignment);
   ~Scavenger();
 
   // Check whether this Scavenger contains this address.
   // During scavenging both the to and from spaces contain "legal" objects.
   // During a scavenge this function only returns true for addresses that will
   // be part of the surviving objects.
-  bool Contains(uword addr) const {
-    return to_->Contains(addr);
-  }
+  bool Contains(uword addr) const { return to_->Contains(addr); }
 
   RawObject* FindObject(FindObjectVisitor* visitor) const;
 
   uword TryAllocate(intptr_t size) {
     ASSERT(Utils::IsAligned(size, kObjectAlignment));
     ASSERT(heap_ != Dart::vm_isolate()->heap());
 #if defined(DEBUG)
     if (FLAG_gc_at_alloc && !scavenging_) {
       Scavenge();
     }
@@ skipping 24 matching lines @@
 
   // Accessors to generate code for inlined allocation.
   uword* TopAddress() { return &top_; }
   uword* EndAddress() { return &end_; }
   static intptr_t top_offset() { return OFFSET_OF(Scavenger, top_); }
   static intptr_t end_offset() { return OFFSET_OF(Scavenger, end_); }
 
   int64_t UsedInWords() const {
     return (top_ - FirstObjectStart()) >> kWordSizeLog2;
   }
-  int64_t CapacityInWords() const {
-    return to_->size_in_words();
-  }
-  int64_t ExternalInWords() const {
-    return external_size_ >> kWordSizeLog2;
-  }
+  int64_t CapacityInWords() const { return to_->size_in_words(); }
+  int64_t ExternalInWords() const { return external_size_ >> kWordSizeLog2; }
   SpaceUsage GetCurrentUsage() const {
     SpaceUsage usage;
     usage.used_in_words = UsedInWords();
     usage.capacity_in_words = CapacityInWords();
     usage.external_in_words = ExternalInWords();
     return usage;
   }
 
   void VisitObjects(ObjectVisitor* visitor) const;
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
   void AddRegionsToObjectSet(ObjectSet* set) const;
 
   void WriteProtect(bool read_only);
 
-  void AddGCTime(int64_t micros) {
-    gc_time_micros_ += micros;
-  }
+  void AddGCTime(int64_t micros) { gc_time_micros_ += micros; }
 
-  int64_t gc_time_micros() const {
-    return gc_time_micros_;
-  }
+  int64_t gc_time_micros() const { return gc_time_micros_; }
 
-  void IncrementCollections() {
-    collections_++;
-  }
+  void IncrementCollections() { collections_++; }
 
-  intptr_t collections() const {
-    return collections_;
-  }
+  intptr_t collections() const { return collections_; }
 
 #ifndef PRODUCT
   void PrintToJSONObject(JSONObject* object) const;
 #endif  // !PRODUCT
 
   void AllocateExternal(intptr_t size);
   void FreeExternal(intptr_t size);
 
  private:
   // Ids for time and data records in Heap::GCStats.
@@ skipping 92 matching lines @@
 
   friend class ScavengerVisitor;
   friend class ScavengerWeakVisitor;
 
   DISALLOW_COPY_AND_ASSIGN(Scavenger);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SCAVENGER_H_