[heap] Remove unswept bytes counter

src/heap/spaces.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/atomic-utils.h"
 #include "src/base/atomicops.h"
@@ skipping 1436 matching lines @@
 // functions increase or decrease one of the non-capacity stats in conjunction
 // with capacity, or else they always balance increases and decreases to the
 // non-capacity stats.
 class AllocationStats BASE_EMBEDDED {
  public:
   AllocationStats() { Clear(); }
 
   // Zero out all the allocation statistics (i.e., no capacity).
   void Clear() {
     capacity_ = 0;
-    max_capacity_ = 0;
     size_ = 0;
+    committed_ = 0;
+    max_committed_ = 0;
   }
 
   void ClearSize() { size_ = capacity_; }
 
   // Reset the allocation statistics (i.e., available = capacity with no wasted
   // or allocated bytes).
   void Reset() {
     size_ = 0;
   }
 
   // Accessors for the allocation statistics.
   intptr_t Capacity() { return capacity_; }
-  intptr_t MaxCapacity() { return max_capacity_; }
   intptr_t Size() { return size_; }
+  intptr_t Committed() { return committed_; }
+  intptr_t MaxCommitted() { return max_committed_; }
 
   // Grow the space by adding available bytes.  They are initially marked as
   // being in use (part of the size), but will normally be immediately freed,
   // putting them on the free list and removing them from size_.
   void ExpandSpace(int size_in_bytes) {
     capacity_ += size_in_bytes;
     size_ += size_in_bytes;
-    if (capacity_ > max_capacity_) {
-      max_capacity_ = capacity_;
-    }
     DCHECK(size_ >= 0);
   }
 
   // Shrink the space by removing available bytes.  Since shrinking is done
   // during sweeping, bytes have been marked as being in use (part of the size)
   // and are hereby freed.
   void ShrinkSpace(int size_in_bytes) {
     capacity_ -= size_in_bytes;
     size_ -= size_in_bytes;
     DCHECK(size_ >= 0);
   }
 
   // Allocate from available bytes (available -> size).
   void AllocateBytes(intptr_t size_in_bytes) {
     size_ += size_in_bytes;
     DCHECK(size_ >= 0);
   }
 
   // Free allocated bytes, making them available (size -> available).
   void DeallocateBytes(intptr_t size_in_bytes) {
     size_ -= size_in_bytes;
-    DCHECK(size_ >= 0);
+    DCHECK_GE(size_, 0);
   }
 
   // Merge {other} into {this}.
   void Merge(const AllocationStats& other) {
     capacity_ += other.capacity_;
     size_ += other.size_;
-    if (other.max_capacity_ > max_capacity_) {
-      max_capacity_ = other.max_capacity_;
+    committed_ += other.committed_;
+    if (committed_ > max_committed_) {
+      max_committed_ = committed_;
     }
   }
 
   void DecreaseCapacity(intptr_t size_in_bytes) {
     capacity_ -= size_in_bytes;
     DCHECK_GE(capacity_, 0);
+    DCHECK_GE(capacity_, size_);
   }
 
   void IncreaseCapacity(intptr_t size_in_bytes) { capacity_ += size_in_bytes; }
 
+  void CommitMemory(intptr_t size_in_bytes) {
+    DCHECK_GE(size_in_bytes, 0);
+    committed_ += size_in_bytes;
+    if (committed_ > max_committed_) {
+      max_committed_ = committed_;
+    }
+  }
+
+  void UncommitMemory(intptr_t size_in_bytes) {
+    DCHECK_GE(size_in_bytes, 0);
+    DCHECK_GE(committed_, size_in_bytes);
+    committed_ -= size_in_bytes;
+  }
+
  private:
   // |capacity_|: The number of object-area bytes (i.e., not including page
-  // bookkeeping structures) currently in the space.
+  //   bookkeeping structures) currently in the space.
   intptr_t capacity_;
 
-  // |max_capacity_|: The maximum capacity ever observed.
-  intptr_t max_capacity_;
-
   // |size_|: The number of allocated bytes.
   intptr_t size_;
+
+  // |committed_|: The number of bytes committed in the corresponding space,
+  //   including page headers. Note that committed memory does not need to
+  //   be larger than capacity/size, as memory can be moved to other spaces.
+  intptr_t committed_;
+
+  // |max_committed_|: The maximum number of bytes committed ever observed.
+  intptr_t max_committed_;
 };
 
 
 // -----------------------------------------------------------------------------
 // Free lists for old object spaces
 
 // The free list category holds a pointer to the top element and a pointer to
 // the end element of the linked list of free memory blocks.
 class FreeListCategory {
  public:
@@ skipping 80 matching lines @@
 //     spaces are called medium.
 // 1048-16383 words: There is a list of spaces this large.  It is used for top
 //     and limit when the object we need to allocate is 256-2047 words in size.
 //     These spaces are call large.
 // At least 16384 words.  This list is for objects of 2048 words or larger.
 //     Empty pages are added to this list.  These spaces are called huge.
 class FreeList {
  public:
   explicit FreeList(PagedSpace* owner);
 
+  // The method concatenates {other} into {this} and returns the added bytes,
+  // including waste.
+  //
+  // Can be used concurrently.
   intptr_t Concatenate(FreeList* other);
 
   // Clear the free list.
   void Reset();
 
   void ResetStats() { wasted_bytes_ = 0; }
 
   // Return the number of bytes available on the free list.
   intptr_t available() {
     return small_list_.available() + medium_list_.available() +
@@ skipping 158 matching lines @@
   // During boot the free_space_map is created, and afterwards we may need
   // to write it into the free list nodes that were already created.
   void RepairFreeListsAfterDeserialization();
 
   // Prepares for a mark-compact GC.
   void PrepareForMarkCompact();
 
   // Current capacity without growing (Size() + Available()).
   intptr_t Capacity() { return accounting_stats_.Capacity(); }
 
-  // Total amount of memory committed for this space.  For paged
-  // spaces this equals the capacity.
-  intptr_t CommittedMemory() override { return Capacity(); }
+  // Total amount of memory committed for this space.
+  intptr_t CommittedMemory() override { return accounting_stats_.Committed(); }
 
   // The maximum amount of memory ever committed for this space.
-  intptr_t MaximumCommittedMemory() { return accounting_stats_.MaxCapacity(); }
+  intptr_t MaximumCommittedMemory() { return accounting_stats_.MaxCommitted(); }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory() override;
 
   void ResetFreeListStatistics();
 
   // Sets the capacity, the available space and the wasted space to zero.
   // The stats are rebuilt during sweeping by adding each page to the
   // capacity and the size when it is encountered.  As free spaces are
   // discovered during the sweeping they are subtracted from the size and added
@@ skipping 121 matching lines @@
   static void ResetCodeStatistics(Isolate* isolate);
 #endif
 
   // Evacuation candidates are swept by evacuator.  Needs to return a valid
   // result before _and_ after evacuation has finished.
   static bool ShouldBeSweptBySweeperThreads(Page* p) {
     return !p->IsEvacuationCandidate() &&
            !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) && !p->WasSwept();
   }
 
-  void IncrementUnsweptFreeBytes(intptr_t by) { unswept_free_bytes_ += by; }
-
-  void IncreaseUnsweptFreeBytes(Page* p) {
-    DCHECK(ShouldBeSweptBySweeperThreads(p));
-    unswept_free_bytes_ += (p->area_size() - p->LiveBytes());
-  }
-
-  void DecrementUnsweptFreeBytes(intptr_t by) { unswept_free_bytes_ -= by; }
-
-  void DecreaseUnsweptFreeBytes(Page* p) {
-    DCHECK(ShouldBeSweptBySweeperThreads(p));
-    unswept_free_bytes_ -= (p->area_size() - p->LiveBytes());
-  }
-
-  void ResetUnsweptFreeBytes() { unswept_free_bytes_ = 0; }
-
   // This function tries to steal size_in_bytes memory from the sweeper threads
   // free-lists. If it does not succeed stealing enough memory, it will wait
   // for the sweeper threads to finish sweeping.
   // It returns true when sweeping is completed and false otherwise.
   bool EnsureSweeperProgress(intptr_t size_in_bytes);
 
   void set_end_of_unswept_pages(Page* page) { end_of_unswept_pages_ = page; }
 
   Page* end_of_unswept_pages() { return end_of_unswept_pages_; }
 
@@ skipping 62 matching lines @@
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   FreeList free_list_;
 
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
-  // The number of free bytes which could be reclaimed by advancing the
-  // concurrent sweeper threads.
-  intptr_t unswept_free_bytes_;
-
   // The sweeper threads iterate over the list of pointer and data space pages
   // and sweep these pages concurrently. They will stop sweeping after the
   // end_of_unswept_pages_ page.
   Page* end_of_unswept_pages_;
 
   // Mutex guarding any concurrent access to the space.
   base::Mutex space_mutex_;
 
   friend class MarkCompactCollector;
   friend class PageIterator;
@@ skipping 917 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_