Use atomic operations to increment/decrement memory usage counts as multiple threads could be alloc…

runtime/vm/pages.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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 326 matching lines @@
   if ((growth_policy == kForceGrowth ||
        !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
       CanIncreaseCapacityInWords(kPageSizeInWords)) {
     HeapPage* page = AllocatePage(type);
     if (page == NULL) {
       return 0;
     }
     // Start of the newly allocated page is the allocated object.
     result = page->object_start();
     // Note: usage_.capacity_in_words is increased by AllocatePage.
-    usage_.used_in_words += size >> kWordSizeLog2;
+    AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
+                                          (size >> kWordSizeLog2));
     // Enqueue the remainder in the free list.
     uword free_start = result + size;
     intptr_t free_size = page->object_end() - free_start;
     if (free_size > 0) {
       if (is_locked) {
         freelist_[type].FreeLocked(free_start, free_size);
       } else {
         freelist_[type].Free(free_start, free_size);
       }
     }
@@ skipping 16 matching lines @@
   if (size < kAllocatablePageSize) {
     if (is_locked) {
       result = freelist_[type].TryAllocateLocked(size, is_protected);
     } else {
       result = freelist_[type].TryAllocate(size, is_protected);
     }
     if (result == 0) {
       result = TryAllocateInFreshPage(size, type, growth_policy, is_locked);
       // usage_ is updated by the call above.
     } else {
-      usage_.used_in_words += size >> kWordSizeLog2;
+      AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),

[Ivan Posva, 2016/01/29 18:54:07]

I am wondering whether we could make this a per thread value that is synced only
occasionally.

[siva, 2016/01/29 20:52:17]

Yes, we could do that, I will do it in a new CL.

+                                            (size >> kWordSizeLog2));
     }
   } else {
     // Large page allocation.
     intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
     if ((page_size_in_words << kWordSizeLog2) < size) {
       // On overflow we fail to allocate.
       return 0;
     }
     SpaceUsage after_allocation = GetCurrentUsage();
     after_allocation.used_in_words += size >> kWordSizeLog2;
     after_allocation.capacity_in_words += page_size_in_words;
     if ((growth_policy == kForceGrowth ||
          !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
         CanIncreaseCapacityInWords(page_size_in_words)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
         // Note: usage_.capacity_in_words is increased by AllocateLargePage.
-        usage_.used_in_words += size >> kWordSizeLog2;
+        AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
+                                              (size >> kWordSizeLog2));
       }
     }
   }
+#ifdef DEBUG
   if (result != 0) {
-#ifdef DEBUG
     // A successful allocation should increase usage_.
     ASSERT(usage_before.used_in_words < usage_.used_in_words);
+  }
+  // Note we cannot assert that a failed allocation should not change
+  // used_in_words as another thread could have changed used_in_words.
 #endif
-  } else {
-#ifdef DEBUG
-    // A failed allocation should not change used_in_words.
-    ASSERT(usage_before.used_in_words == usage_.used_in_words);
-#endif
-  }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
   void PageSpace::AcquireDataLock() {
     freelist_[HeapPage::kData].mutex()->Lock();
   }
 
 
   void PageSpace::ReleaseDataLock() {
     freelist_[HeapPage::kData].mutex()->Unlock();
   }
 
 
 void PageSpace::AllocateExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
-  usage_.external_in_words += size_in_words;
+  AtomicOperations::FetchAndIncrementBy(&(usage_.external_in_words),
+                                        size_in_words);
   // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
-  usage_.external_in_words -= size_in_words;
+  AtomicOperations::FetchAndDecrementBy(&(usage_.external_in_words),
+                                        size_in_words);
 }
 
 
 // Provides exclusive access to all pages, and ensures they are walkable.
 class ExclusivePageIterator : ValueObject {
  public:
   explicit ExclusivePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->pages_;
@@ skipping 379 matching lines @@
   // Make code pages writable.
   WriteProtectCode(false);
 
   // Save old value before GCMarker visits the weak persistent handles.
   SpaceUsage usage_before = GetCurrentUsage();
 
   // Mark all reachable old-gen objects.
   bool collect_code = FLAG_collect_code && ShouldCollectCode();
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
-  usage_.used_in_words = marker.marked_words();
+  AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
+                                        marker.marked_words());
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
   // Abandon the remainder of the bump allocation block.
   AbandonBumpAllocation();
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
   freelist_[HeapPage::kExecutable].Reset();
 
   int64_t mid2 = OS::GetCurrentTimeMicros();
@@ skipping 145 matching lines @@
         freelist_[HeapPage::kData].Free(bump_top_, remaining);
       }
     }
     bump_top_ = reinterpret_cast<uword>(block);
     bump_end_ = bump_top_ + block_size;
     remaining = block_size;
   }
   ASSERT(remaining >= size);
   uword result = bump_top_;
   bump_top_ += size;
-  usage_.used_in_words += size >> kWordSizeLog2;
+  AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
+                                        (size >> kWordSizeLog2));
   // Note: Remaining block is unwalkable until MakeIterable is called.
 #ifdef DEBUG
   if (bump_top_ < bump_end_) {
     // Fail fast if we try to walk the remaining block.
     COMPILE_ASSERT(kIllegalCid == 0);
     *reinterpret_cast<uword*>(bump_top_) = 0;
   }
 #endif  // DEBUG
   return result;
 }
 
 
 uword PageSpace::TryAllocateDataBump(intptr_t size,
                                      GrowthPolicy growth_policy) {
   return TryAllocateDataBumpInternal(size, growth_policy, false);
 }
 
 
 uword PageSpace::TryAllocateDataBumpLocked(intptr_t size,
                                            GrowthPolicy growth_policy) {
   return TryAllocateDataBumpInternal(size, growth_policy, true);
 }
 
 
 uword PageSpace::TryAllocatePromoLocked(intptr_t size,
                                         GrowthPolicy growth_policy) {
   FreeList* freelist = &freelist_[HeapPage::kData];
   uword result = freelist->TryAllocateSmallLocked(size);
   if (result != 0) {
-    usage_.used_in_words += size >> kWordSizeLog2;
+    AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
+                                          (size >> kWordSizeLog2));
     return result;
   }
   result = TryAllocateDataBumpLocked(size, growth_policy);
   if (result != 0) return result;
   return TryAllocateDataLocked(size, growth_policy);
 }
 
 
 uword PageSpace::TryAllocateSmiInitializedLocked(intptr_t size,
                                                  GrowthPolicy growth_policy) {
@@ skipping 166 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>((static_cast<double>(gc_time) /
                                    static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart