clang-format runtime/vm

runtime/vm/pages.h

 // 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.
 
 #ifndef RUNTIME_VM_PAGES_H_
 #define RUNTIME_VM_PAGES_H_
 
 #include "vm/freelist.h"
 #include "vm/globals.h"
 #include "vm/lockers.h"
@@ skipping 10 matching lines @@
 
 // Forward declarations.
 class Heap;
 class JSONObject;
 class ObjectPointerVisitor;
 class ObjectSet;
 
 // A page containing old generation objects.
 class HeapPage {
  public:
-  enum PageType {
-    kData = 0,
-    kExecutable,
-    kReadOnlyData,
-    kNumPageTypes
-  };
+  enum PageType { kData = 0, kExecutable, kReadOnlyData, kNumPageTypes };
 
   HeapPage* next() const { return next_; }
   void set_next(HeapPage* next) { next_ = next; }
 
-  bool Contains(uword addr) {
-    return memory_->Contains(addr);
-  }
+  bool Contains(uword addr) { return memory_->Contains(addr); }
 
-  uword object_start() const {
-    return memory_->start() + ObjectStartOffset();
-  }
-  uword object_end() const {
-    return object_end_;
-  }
+  uword object_start() const { return memory_->start() + ObjectStartOffset(); }
+  uword object_end() const { return object_end_; }
 
-  PageType type() const {
-    return type_;
-  }
+  PageType type() const { return type_; }
 
   bool embedder_allocated() const { return memory_->embedder_allocated(); }
 
   void VisitObjects(ObjectVisitor* visitor) const;
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
   RawObject* FindObject(FindObjectVisitor* visitor) const;
 
   void WriteProtect(bool read_only);
 
@@ skipping 65 matching lines @@
   ~PageSpaceController();
 
   // Returns whether growing to 'after' should trigger a GC.
   // This method can be called before allocation (e.g., pretenuring) or after
   // (e.g., promotion), as it does not change the state of the controller.
   bool NeedsGarbageCollection(SpaceUsage after) const;
 
   // Should be called after each collection to update the controller state.
   void EvaluateGarbageCollection(SpaceUsage before,
                                  SpaceUsage after,
-                                 int64_t start, int64_t end);
+                                 int64_t start,
+                                 int64_t end);
 
   int64_t last_code_collection_in_us() { return last_code_collection_in_us_; }
   void set_last_code_collection_in_us(int64_t t) {
     last_code_collection_in_us_ = t;
   }
 
-  void set_last_usage(SpaceUsage current) {
-    last_usage_ = current;
-  }
+  void set_last_usage(SpaceUsage current) { last_usage_ = current; }
 
-  void Enable() {
-    is_enabled_ = true;
-  }
-  void Disable() {
-    is_enabled_ = false;
-  }
-  bool is_enabled() {
-    return is_enabled_;
-  }
+  void Enable() { is_enabled_ = true; }
+  void Disable() { is_enabled_ = false; }
+  bool is_enabled() { return is_enabled_; }
 
  private:
   Heap* heap_;
 
   bool is_enabled_;
 
   // Usage after last evaluated GC or last enabled.
   SpaceUsage last_usage_;
 
   // Pages of capacity growth allowed before next GC is advised.
@@ skipping 22 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpaceController);
 };
 
 
 class PageSpace {
  public:
   // TODO(iposva): Determine heap sizes and tune the page size accordingly.
   static const intptr_t kPageSizeInWords = 256 * KBInWords;
 
-  enum GrowthPolicy {
-    kControlGrowth,
-    kForceGrowth
-  };
+  enum GrowthPolicy { kControlGrowth, kForceGrowth };
 
   PageSpace(Heap* heap,
             intptr_t max_capacity_in_words,
             intptr_t max_external_in_words);
   ~PageSpace();
 
   uword TryAllocate(intptr_t size,
                     HeapPage::PageType type = HeapPage::kData,
                     GrowthPolicy growth_policy = kControlGrowth) {
     bool is_protected =
         (type == HeapPage::kExecutable) && FLAG_write_protect_code;
     bool is_locked = false;
-    return TryAllocateInternal(
-        size, type, growth_policy, is_protected, is_locked);
+    return TryAllocateInternal(size, type, growth_policy, is_protected,
+                               is_locked);
   }
 
   bool NeedsGarbageCollection() const {
     return page_space_controller_.NeedsGarbageCollection(usage_) ||
            NeedsExternalGC();
   }
 
   int64_t UsedInWords() const { return usage_.used_in_words; }
   int64_t CapacityInWords() const {
     MutexLocker ml(pages_lock_);
     return usage_.capacity_in_words;
   }
   void IncreaseCapacityInWords(intptr_t increase_in_words) {
-     MutexLocker ml(pages_lock_);
-     IncreaseCapacityInWordsLocked(increase_in_words);
+    MutexLocker ml(pages_lock_);
+    IncreaseCapacityInWordsLocked(increase_in_words);
   }
   void IncreaseCapacityInWordsLocked(intptr_t increase_in_words) {
     DEBUG_ASSERT(pages_lock_->IsOwnedByCurrentThread());
     usage_.capacity_in_words += increase_in_words;
     UpdateMaxCapacityLocked();
   }
 
   void UpdateMaxCapacityLocked();
   void UpdateMaxUsed();
 
-  int64_t ExternalInWords() const {
-    return usage_.external_in_words;
-  }
+  int64_t ExternalInWords() const { return usage_.external_in_words; }
   SpaceUsage GetCurrentUsage() const {
     MutexLocker ml(pages_lock_);
     return usage_;
   }
 
   bool Contains(uword addr) const;
   bool Contains(uword addr, HeapPage::PageType type) const;
-  bool IsValidAddress(uword addr) const {
-    return Contains(addr);
-  }
+  bool IsValidAddress(uword addr) const { return Contains(addr); }
 
   void VisitObjects(ObjectVisitor* visitor) const;
   void VisitObjectsNoEmbedderPages(ObjectVisitor* visitor) const;
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
   RawObject* FindObject(FindObjectVisitor* visitor,
                         HeapPage::PageType type) const;
 
   // Checks if enough time has elapsed since the last attempt to collect
   // code.
@@ skipping 10 matching lines @@
   }
 
   void SetGrowthControlState(bool state) {
     if (state) {
       page_space_controller_.Enable();
     } else {
       page_space_controller_.Disable();
     }
   }
 
-  bool GrowthControlState() {
-    return page_space_controller_.is_enabled();
-  }
+  bool GrowthControlState() { return page_space_controller_.is_enabled(); }
 
   bool NeedsExternalGC() const {
     return (max_external_in_words_ != 0) &&
-        (ExternalInWords() > max_external_in_words_);
+           (ExternalInWords() > max_external_in_words_);
   }
 
   // Note: Code pages are made executable/non-executable when 'read_only' is
   // true/false, respectively.
   void WriteProtect(bool read_only);
   void WriteProtectCode(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;
   void PrintHeapMapToJSONStream(Isolate* isolate, JSONStream* stream) const;
 #endif  // PRODUCT
 
   void AllocateExternal(intptr_t size);
   void FreeExternal(intptr_t size);
 
   // Bulk data allocation.
   void AcquireDataLock();
   void ReleaseDataLock();
 
   uword TryAllocateDataLocked(intptr_t size, GrowthPolicy growth_policy) {
     bool is_protected = false;
     bool is_locked = true;
-    return TryAllocateInternal(size,
-                               HeapPage::kData,
-                               growth_policy,
+    return TryAllocateInternal(size, HeapPage::kData, growth_policy,
                                is_protected, is_locked);
   }
 
   Monitor* tasks_lock() const { return tasks_lock_; }
   intptr_t tasks() const { return tasks_; }
   void set_tasks(intptr_t val) {
     ASSERT(val >= 0);
     tasks_ = val;
   }
 
@@ skipping 116 matching lines @@
   friend class HeapIterationScope;
   friend class PageSpaceController;
   friend class SweeperTask;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpace);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PAGES_H_