Change signature of atomic increment/decrement functions to return void.

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 328 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.
-    AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
-                                          (size >> kWordSizeLog2));
+    AtomicOperations::IncrementBy(&(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 {
-      AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
-                                            (size >> kWordSizeLog2));
+      AtomicOperations::IncrementBy(&(usage_.used_in_words),
+                                    (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.
-        AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
-                                              (size >> kWordSizeLog2));
+        AtomicOperations::IncrementBy(&(usage_.used_in_words),
+                                      (size >> kWordSizeLog2));
       }
     }
   }
 #ifdef DEBUG
   if (result != 0) {
     // 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
   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;
-  AtomicOperations::FetchAndIncrementBy(&(usage_.external_in_words),
-                                        size_in_words);
+  AtomicOperations::IncrementBy(&(usage_.external_in_words), size_in_words);
   // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
-  AtomicOperations::FetchAndDecrementBy(&(usage_.external_in_words),
-                                        size_in_words);
+  AtomicOperations::DecrementBy(&(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 545 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;
-  AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
-                                        (size >> kWordSizeLog2));
+  AtomicOperations::IncrementBy(&(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) {
-    AtomicOperations::FetchAndIncrementBy(&(usage_.used_in_words),
-                                          (size >> kWordSizeLog2));
+    AtomicOperations::IncrementBy(&(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