clang-format runtime/vm

runtime/vm/freelist.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/freelist.h"
 
 #include "vm/bit_set.h"
 #include "vm/hash_map.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
@@ skipping 59 matching lines @@
 uword FreeList::TryAllocateLocked(intptr_t size, bool is_protected) {
   DEBUG_ASSERT(mutex_->IsOwnedByCurrentThread());
   // Precondition: is_protected is false or else all free list elements are
   // in non-writable pages.
 
   // Postcondition: if allocation succeeds, the allocated block is writable.
   int index = IndexForSize(size);
   if ((index != kNumLists) && free_map_.Test(index)) {
     FreeListElement* element = DequeueElement(index);
     if (is_protected) {
-      bool status =
-          VirtualMemory::Protect(reinterpret_cast<void*>(element),
-                                 size,
-                                 VirtualMemory::kReadWrite);
+      bool status = VirtualMemory::Protect(reinterpret_cast<void*>(element),
+                                           size, VirtualMemory::kReadWrite);
       ASSERT(status);
     }
     return reinterpret_cast<uword>(element);
   }
 
   if ((index + 1) < kNumLists) {
     intptr_t next_index = free_map_.Next(index + 1);
     if (next_index != -1) {
       // Dequeue an element from the list, split and enqueue the remainder in
       // the appropriate list.
       FreeListElement* element = DequeueElement(next_index);
       if (is_protected) {
         // Make the allocated block and the header of the remainder element
         // writable.  The remainder will be non-writable if necessary after
         // the call to SplitElementAfterAndEnqueue.
         // If the remainder size is zero, only the element itself needs to
         // be made writable.
         intptr_t remainder_size = element->Size() - size;
         intptr_t region_size =
             size + FreeListElement::HeaderSizeFor(remainder_size);
         bool status =
             VirtualMemory::Protect(reinterpret_cast<void*>(element),
-                                   region_size,
-                                   VirtualMemory::kReadWrite);
+                                   region_size, VirtualMemory::kReadWrite);
         ASSERT(status);
       }
       SplitElementAfterAndEnqueue(element, size, is_protected);
       return reinterpret_cast<uword>(element);
     }
   }
 
   FreeListElement* previous = NULL;
   FreeListElement* current = free_lists_[kNumLists];
   while (current != NULL) {
     if (current->Size() >= size) {
       // Found an element large enough to hold the requested size. Dequeue,
       // split and enqueue the remainder.
       intptr_t remainder_size = current->Size() - size;
       intptr_t region_size =
           size + FreeListElement::HeaderSizeFor(remainder_size);
       if (is_protected) {
         // Make the allocated block and the header of the remainder element
         // writable.  The remainder will be non-writable if necessary after
         // the call to SplitElementAfterAndEnqueue.
         bool status =
             VirtualMemory::Protect(reinterpret_cast<void*>(current),
-                                   region_size,
-                                   VirtualMemory::kReadWrite);
+                                   region_size, VirtualMemory::kReadWrite);
         ASSERT(status);
       }
 
       if (previous == NULL) {
         free_lists_[kNumLists] = current->next();
       } else {
         // If the previous free list element's next field is protected, it
         // needs to be unprotected before storing to it and reprotected
         // after.
         bool target_is_protected = false;
         uword target_address = 0L;
         if (is_protected) {
           uword writable_start = reinterpret_cast<uword>(current);
           uword writable_end = writable_start + region_size - 1;
           target_address = previous->next_address();
           target_is_protected =
               !VirtualMemory::InSamePage(target_address, writable_start) &&
               !VirtualMemory::InSamePage(target_address, writable_end);
         }
         if (target_is_protected) {
           bool status =
               VirtualMemory::Protect(reinterpret_cast<void*>(target_address),
-                                     kWordSize,
-                                     VirtualMemory::kReadWrite);
+                                     kWordSize, VirtualMemory::kReadWrite);
           ASSERT(status);
         }
         previous->set_next(current->next());
         if (target_is_protected) {
           bool status =
               VirtualMemory::Protect(reinterpret_cast<void*>(target_address),
-                                     kWordSize,
-                                     VirtualMemory::kReadExecute);
+                                     kWordSize, VirtualMemory::kReadExecute);
           ASSERT(status);
         }
       }
       SplitElementAfterAndEnqueue(current, size, is_protected);
       return reinterpret_cast<uword>(current);
     }
     previous = current;
     current = current->next();
   }
   return 0;
@@ skipping 39 matching lines @@
     index = kNumLists;
   }
   return index;
 }
 
 
 void FreeList::EnqueueElement(FreeListElement* element, intptr_t index) {
   FreeListElement* next = free_lists_[index];
   if (next == NULL && index != kNumLists) {
     free_map_.Set(index, true);
-    last_free_small_size_ = Utils::Maximum(last_free_small_size_,
-                                           index << kObjectAlignmentLog2);
+    last_free_small_size_ =
+        Utils::Maximum(last_free_small_size_, index << kObjectAlignmentLog2);
   }
   element->set_next(next);
   free_lists_[index] = element;
 }
 
 
 FreeListElement* FreeList::DequeueElement(intptr_t index) {
   FreeListElement* result = free_lists_[index];
   FreeListElement* next = result->next();
   if (next == NULL && index != kNumLists) {
@@ skipping 31 matching lines @@
   intptr_t small_bytes = 0;
   for (int i = 0; i < kNumLists; ++i) {
     if (free_lists_[i] == NULL) {
       continue;
     }
     small_sizes += 1;
     intptr_t list_length = LengthLocked(i);
     small_objects += list_length;
     intptr_t list_bytes = list_length * i * kObjectAlignment;
     small_bytes += list_bytes;
-    OS::Print("small %3d [%8d bytes] : "
-              "%8" Pd " objs; %8.1f KB; %8.1f cum KB\n",
-              i,
-              i * kObjectAlignment,
-              list_length,
-              list_bytes / static_cast<double>(KB),
-              small_bytes / static_cast<double>(KB));
+    OS::Print(
+        "small %3d [%8d bytes] : "
+        "%8" Pd " objs; %8.1f KB; %8.1f cum KB\n",
+        i, i * kObjectAlignment, list_length,
+        list_bytes / static_cast<double>(KB),
+        small_bytes / static_cast<double>(KB));
   }
 }
 
 
 class IntptrPair {
  public:
   IntptrPair() : first_(-1), second_(-1) {}
   IntptrPair(intptr_t first, intptr_t second)
       : first_(first), second_(second) {}
 
@@ skipping 33 matching lines @@
   }
 
   MallocDirectChainedHashMap<NumbersKeyValueTrait<IntptrPair> >::Iterator it =
       map.GetIterator();
   IntptrPair* pair;
   while ((pair = it.Next()) != NULL) {
     intptr_t size = pair->first();
     intptr_t list_length = pair->second();
     intptr_t list_bytes = list_length * size;
     large_bytes += list_bytes;
-    OS::Print("large %3" Pd " [%8" Pd " bytes] : "
+    OS::Print("large %3" Pd " [%8" Pd
+              " bytes] : "
               "%8" Pd " objs; %8.1f KB; %8.1f cum KB\n",
-              size / kObjectAlignment,
-              size,
-              list_length,
+              size / kObjectAlignment, size, list_length,
               list_bytes / static_cast<double>(KB),
               large_bytes / static_cast<double>(KB));
   }
 }
 
 
 void FreeList::Print() const {
   MutexLocker ml(mutex_);
   PrintSmall();
   PrintLarge();
@@ skipping 15 matching lines @@
   EnqueueElement(element, remainder_index);
 
   // Postcondition: when allocating in a protected page, the remainder
   // element is no longer writable unless it is in the same page as the
   // allocated element.  (The allocated element is still writable, and the
   // remainder element will be protected when the allocated one is).
   if (is_protected &&
       !VirtualMemory::InSamePage(remainder_address - 1, remainder_address)) {
     bool status =
         VirtualMemory::Protect(reinterpret_cast<void*>(remainder_address),
-                               remainder_size,
-                               VirtualMemory::kReadExecute);
+                               remainder_size, VirtualMemory::kReadExecute);
     ASSERT(status);
   }
 }
 
 
 FreeListElement* FreeList::TryAllocateLarge(intptr_t minimum_size) {
   MutexLocker ml(mutex_);
   return TryAllocateLargeLocked(minimum_size);
 }
 
@@ skipping 34 matching lines @@
     if (next_index != -1) {
       FreeListElement* element = DequeueElement(next_index);
       SplitElementAfterAndEnqueue(element, size, false);
       return reinterpret_cast<uword>(element);
     }
   }
   return 0;
 }
 
 }  // namespace dart