Estimate a (close) upper bound on the size of black-marked objects on each page.

src/spaces.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 100 matching lines @@
 
 #define ASSERT_MAP_PAGE_INDEX(index)                                           \
   ASSERT((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
 
 
 class PagedSpace;
 class MemoryAllocator;
 class AllocationInfo;
 class Space;
 class FreeList;
-
+class MemoryChunk;
 
 // TODO(gc): Check that this all gets inlined and register allocated on
 // all platforms.
 class MarkBit {
  public:
   typedef uint32_t CellType;
 
   inline MarkBit(CellType* cell, CellType mask, bool data_only)
       : cell_(cell), mask_(mask), data_only_(data_only) { }
 
@@ skipping 83 matching lines @@
   INLINE(static Bitmap* FromAddress(Address addr)) {
     return reinterpret_cast<Bitmap*>(addr);
   }
 
   inline MarkBit MarkBitFromIndex(uint32_t index, bool data_only = false) {
     MarkBit::CellType mask = 1 << (index & kBitIndexMask);
     MarkBit::CellType* cell = this->cells() + (index >> kBitsPerCellLog2);
     return MarkBit(cell, mask, data_only);
   }
 
-  INLINE(void ClearRange(uint32_t start, uint32_t size)) {
-    const uint32_t end = start + size;
-    const uint32_t start_cell = start >> kBitsPerCellLog2;
-    const uint32_t end_cell = end >> kBitsPerCellLog2;
-    ASSERT((start & kBitIndexMask) == 0);
-    ASSERT((end & kBitIndexMask) == 0);
-
-    ASSERT(static_cast<int>(start_cell) < CellsCount());
-    ASSERT(static_cast<int>(end_cell) <= CellsCount());
-
-    for (uint32_t cell = start_cell; cell < end_cell; cell++) {
-      cells()[cell] = 0;
-    }
-  }
-
-  INLINE(void Clear()) {
-    for (int i = 0; i < CellsCount(); i++) cells()[i] = 0;
-  }
+  static inline void Clear(MemoryChunk* chunk);
 
   static void PrintWord(uint32_t word, uint32_t himask = 0) {
     for (uint32_t mask = 1; mask != 0; mask <<= 1) {
       if ((mask & himask) != 0) PrintF("[");
       PrintF((mask & word) ? "1" : "0");
       if ((mask & himask) != 0) PrintF("]");
     }
   }
 
   class CellPrinter {
@@ skipping 165 matching lines @@
   // Set or clear multiple flags at a time. The flags in the mask
   // are set to the value in "flags", the rest retain the current value
   // in flags_.
   void SetFlags(intptr_t flags, intptr_t mask) {
     flags_ = (flags_ & ~mask) | (flags & mask);
   }
 
   // Return all current flags.
   intptr_t GetFlags() { return flags_; }
 
+  // Manage live byte count (count of bytes known to be live,
+  // because they are marked black).
+  void ResetLiveBytes() {
+    live_byte_count_ = 0;
+  }
+  void IncrementLiveBytes(int by) {
+    live_byte_count_ += by;
+  }
+  int LiveBytes() { return live_byte_count_; }
+  static void IncrementLiveBytes(Address address, int by) {
+    MemoryChunk::FromAddress(address)->IncrementLiveBytes(by);
+  }
+
   static const intptr_t kAlignment = (1 << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
-  static const size_t kHeaderSize = kPointerSize + kPointerSize + kPointerSize +
-    kPointerSize + kPointerSize + kPointerSize + kPointerSize + kPointerSize;
+  static const intptr_t kLiveBytesOffset =
+      kPointerSize + kPointerSize + kPointerSize + kPointerSize +
+      kPointerSize + kPointerSize + kIntSize;
+
+  static const size_t kHeaderSize = kLiveBytesOffset + kIntSize;
 
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
   static const int kObjectStartOffset = kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
@@ skipping 57 matching lines @@
   size_t size_;
   intptr_t flags_;
   // The identity of the owning space.  This is tagged as a failure pointer, but
   // no failure can be in an object, so this can be distinguished from any entry
   // in a fixed array.
   Address owner_;
   Heap* heap_;
   // Used by the store buffer to keep track of which pages to mark scan-on-
   // scavenge.
   int store_buffer_counter_;
+  // Count of bytes marked black on page.
+  int live_byte_count_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Executability executable,
                                  Space* owner);
 
   friend class MemoryAllocator;
 };
 
@@ skipping 906 matching lines @@
   bool IsFragmented(Page* p) {
     intptr_t sizes[4];
     free_list_.CountFreeListItems(p, sizes);
 
     intptr_t ratio =
         (sizes[0] * 5 + sizes[1]) * 100 / Page::kObjectAreaSize;
 
     if (FLAG_trace_fragmentation) {
       PrintF("%p: %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %s\n",
              reinterpret_cast<void*>(p),
-             sizes[0],
+             static_cast<int>(sizes[0]),
              static_cast<double>(sizes[0] * 100) / Page::kObjectAreaSize,
-             sizes[1],
+             static_cast<int>(sizes[1]),
              static_cast<double>(sizes[1] * 100) / Page::kObjectAreaSize,
-             sizes[2],
+             static_cast<int>(sizes[2]),
              static_cast<double>(sizes[2] * 100) / Page::kObjectAreaSize,
-             sizes[3],
+             static_cast<int>(sizes[3]),
              static_cast<double>(sizes[3] * 100) / Page::kObjectAreaSize,
              (ratio > 15) ? "[fragmented]" : "");
     }
 
     return ratio > 15;
   }
 
  protected:
   // Maximum capacity of this space.
   intptr_t max_capacity_;
@@ skipping 1064 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_