[heap] Remove unswept bytes counter

src/heap/mark-compact.cc

Index: src/heap/mark-compact.cc
diff --git a/src/heap/mark-compact.cc b/src/heap/mark-compact.cc
index d161b1853d8afb662193e416dfa471380f93164b..c3976e2db45fd53b6b818769e685eaf9b95f2ee6 100644
--- a/src/heap/mark-compact.cc
+++ b/src/heap/mark-compact.cc
@@ -569,9 +569,6 @@ void MarkCompactCollector::EnsureSweepingCompleted() {
   RefillFreeList(heap()->paged_space(OLD_SPACE));
   RefillFreeList(heap()->paged_space(CODE_SPACE));
   RefillFreeList(heap()->paged_space(MAP_SPACE));
-  heap()->paged_space(OLD_SPACE)->ResetUnsweptFreeBytes();
-  heap()->paged_space(CODE_SPACE)->ResetUnsweptFreeBytes();
-  heap()->paged_space(MAP_SPACE)->ResetUnsweptFreeBytes();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap && !evacuation()) {
@@ -606,9 +603,8 @@ void MarkCompactCollector::RefillFreeList(PagedSpace* space) {
     return;
   }
 
-  intptr_t freed_bytes = space->free_list()->Concatenate(free_list);
-  space->AddToAccountingStats(freed_bytes);
-  space->DecrementUnsweptFreeBytes(freed_bytes);
+  intptr_t added = space->free_list()->Concatenate(free_list);
+  space->accounting_stats_.IncreaseCapacity(added);
 }
 
 
@@ -4354,9 +4350,9 @@ void MarkCompactCollector::SweepSpace(PagedSpace* space, SweeperType sweeper) {
           PrintF("Sweeping 0x%" V8PRIxPTR " released page.\n",
                  reinterpret_cast<intptr_t>(p));
         }
-        // Adjust unswept free bytes because releasing a page expects said
+        // Adjust bytes allocated because releasing a page expects said
         // counter to be accurate for unswept pages.
-        space->IncreaseUnsweptFreeBytes(p);
+        space->accounting_stats_.AllocateBytes(p->area_size());

[Hannes Payer (out of office), 2015/10/02 06:52:09]

This seems to be non-logical. We do we account here for allocated bytes, which
are not allocated.

[Michael Lippautz, 2015/10/02 13:04:35]

I agree, the change here is mechanical though. ReleasePage has a path where it
subtracts the appropriate amount of bytes.

I would rather try to fix the accounting itself in a separate CL and keep the
changes to the swept bytes counter mechanical here.

[Hannes Payer (out of office), 2015/10/05 15:23:26]

The logic is just broken Let's fix it right away.

[Michael Lippautz, 2015/10/07 13:15:39]

Done. I removed the corresponding parts. ReleasePage() has 2 callers, and the
accounting was relevant for the case where we have not swept the page.

         space->ReleasePage(p);
         continue;
       }
@@ -4390,7 +4386,8 @@ void MarkCompactCollector::SweepSpace(PagedSpace* space, SweeperType sweeper) {
                    reinterpret_cast<intptr_t>(p));
           }
           p->parallel_sweeping_state().SetValue(MemoryChunk::kSweepingPending);
-          space->IncreaseUnsweptFreeBytes(p);
+          int to_sweep = p->area_size() - p->LiveBytes();
+          space->accounting_stats_.ShrinkSpace(to_sweep);

[Hannes Payer (out of office), 2015/10/02 06:52:09]

Here we are going to shrink the capacity, a lot. Almost every page will be
selected for concurrent sweeping resulting in a very small capacity. Our tools
may report a completely wrong picture. CommittedMemory() reports this counter to
the statistics extensions.

[Michael Lippautz, 2015/10/02 13:04:35]

I changed Committed() and MaxCommitted() to be based on an actual committed
bytes counters. This way we
- have accurate capacity/size/waste throughout sweeping, where capacity is the
actually usable memory in a space (even during sweeping).
- can later on extend on borrowing memory in RefillFreeList.
- have accurate accounting for committed memory, including page headers. We
probably get worse fragmentation as we so far ignored the page headers.

Note that there is no invariant that committed >= capacity, as we could borrow
memory. (Also, fragmentation during compaction could be quite high as
CompactionSpaces are not considered for overall statistics.)

WDYT?

         }
         space->set_end_of_unswept_pages(p);
         break;