Oilpan: Implement mark/sweep stats collection for free list profiler.

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 904 matching lines @@
     json->beginArray("largeObjects");
     for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next()) {
         json->beginDictionary();
         largeObject->snapshot(json, info);
         json->endDictionary();
     }
     json->endArray();
 
     json->setInteger("pageCount", info->pageCount - previousPageCount);
 }
+
+void ThreadHeap::incrementMarkedObjectsAge()
+{
+    for (HeapPage* page = m_firstPage; page; page = page->next())
+        page->incrementMarkedObjectsAge();
+    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+        largeObject->incrementMarkedObjectsAge();
+}
 #endif
 
 void FreeList::addToFreeList(Address address, size_t size)
 {
     ASSERT(size < blinkPagePayloadSize());
     // The free list entries are only pointer aligned (but when we allocate
     // from them we are 8 byte aligned due to the header size).
     ASSERT(!((reinterpret_cast<uintptr_t>(address) + sizeof(HeapObjectHeader)) & allocationMask));
     ASSERT(!(size & allocationMask));
     ASAN_POISON_MEMORY_REGION(address, size);
@@ skipping 591 matching lines @@
     json.beginArray("perBucketEntryCount");
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         json.pushInteger(bucketStats[i].entryCount);
     json.endArray();
 
     json.beginArray("perBucketFreeSize");
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         json.pushInteger(bucketStats[i].freeSize);
     json.endArray();
 }
+
+void ThreadHeap::countMarkedObjects(ClassAgeCountsMap& classAgeCounts) const
+{
+    for (HeapPage* page = m_firstPage; page; page = page->next())
+        page->countMarkedObjects(classAgeCounts);
+    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+        largeObject->countMarkedObjects(classAgeCounts);
+}
+
+void ThreadHeap::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts) const
+{
+    for (HeapPage* page = m_firstPage; page; page = page->next())
+        page->countObjectsToSweep(classAgeCounts);
+    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+        largeObject->countObjectsToSweep(classAgeCounts);
+}
 #endif
 
 void FreeList::clear()
 {
     m_biggestFreeListIndex = 0;
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         m_freeLists[i] = nullptr;
 }
 
 int FreeList::bucketIndexForSize(size_t size)
@@ skipping 249 matching lines @@
         size_t tag = info->getClassTag(Heap::gcInfo(header->gcInfoIndex()));
         size_t age = header->age();
         if (json)
             json->pushInteger(tag);
         if (header->isMarked()) {
             info->liveCount[tag] += 1;
             info->liveSize[tag] += header->size();
             // Count objects that are live when promoted to the final generation.
             if (age == maxHeapObjectAge - 1)
                 info->generations[tag][maxHeapObjectAge] += 1;
-            header->incrementAge();
         } else {
             info->deadCount[tag] += 1;
             info->deadSize[tag] += header->size();
             // Count objects that are dead before the final generation.
             if (age < maxHeapObjectAge)
                 info->generations[tag][age] += 1;
         }
     }
 }
+
+void HeapPage::incrementMarkedObjectsAge()
+{
+    HeapObjectHeader* header = nullptr;

[haraken, 2015/02/06 06:39:20]

You can declare HeapObjectHeader* inside the loop. The same comment for other
methods in this file.

[Yuta Kitamura, 2015/02/06 07:45:45]

It is used in the third part of the "for" expression
below.

+    for (Address address = payload(); address < payloadEnd(); address += header->size()) {
+        header = reinterpret_cast<HeapObjectHeader*>(address);
+        if (header->isMarked())
+            header->incrementAge();
+    }
+}
+
+void HeapPage::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
+{
+    HeapObjectHeader* header = nullptr;
+    for (Address address = payload(); address < payloadEnd(); address += header->size()) {
+        header = reinterpret_cast<HeapObjectHeader*>(address);
+        if (header->isMarked()) {
+            String className(classOf(header->payload()));
+            ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
+        }
+    }
+}
+
+void HeapPage::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
+{
+    HeapObjectHeader* header = nullptr;
+    for (Address address = payload(); address < payloadEnd(); address += header->size()) {
+        header = reinterpret_cast<HeapObjectHeader*>(address);
+        if (!header->isFree() && !header->isMarked()) {
+            String className(classOf(header->payload()));
+            ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
+        }
+    }
+}
 #endif
 
 size_t LargeObject::objectPayloadSizeForTesting()
 {
     markAsSwept();
     return payloadSize();
 }
 
 #if ENABLE(GC_PROFILING)
 const GCInfo* LargeObject::findGCInfo(Address address)
 {
     if (!containedInObjectPayload(address))
         return nullptr;
     HeapObjectHeader* header = heapObjectHeader();
     return Heap::gcInfo(header->gcInfoIndex());
 }
 
 void LargeObject::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
     HeapObjectHeader* header = heapObjectHeader();
     size_t tag = info->getClassTag(Heap::gcInfo(header->gcInfoIndex()));
     size_t age = header->age();
     if (header->isMarked()) {
         info->liveCount[tag] += 1;
         info->liveSize[tag] += header->size();
         // Count objects that are live when promoted to the final generation.
         if (age == maxHeapObjectAge - 1)
             info->generations[tag][maxHeapObjectAge] += 1;
-        header->incrementAge();
     } else {
         info->deadCount[tag] += 1;
         info->deadSize[tag] += header->size();
         // Count objects that are dead before the final generation.
         if (age < maxHeapObjectAge)
             info->generations[tag][age] += 1;
     }
 
     if (json) {
         json->setInteger("class", tag);
         json->setInteger("size", header->size());
         json->setInteger("isMarked", header->isMarked());
     }
 }
+
+void LargeObject::incrementMarkedObjectsAge()
+{
+    HeapObjectHeader* header = heapObjectHeader();
+    if (header->isMarked())
+        header->incrementAge();
+}
+
+void LargeObject::countMarkedObjects(ClassAgeCountsMap& classAgeCounts)
+{
+    HeapObjectHeader* header = heapObjectHeader();
+    if (header->isMarked()) {
+        String className(classOf(header->payload()));
+        ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
+    }
+}
+
+void LargeObject::countObjectsToSweep(ClassAgeCountsMap& classAgeCounts)
+{
+    HeapObjectHeader* header = heapObjectHeader();
+    if (!header->isFree() && !header->isMarked()) {
+        String className(classOf(header->payload()));
+        ++(classAgeCounts.add(className, AgeCounts()).storedValue->value.ages[header->age()]);
+    }
+}
 #endif
 
 void HeapDoesNotContainCache::flush()
 {
     if (m_hasEntries) {
         for (int i = 0; i < numberOfEntries; ++i)
             m_entries[i] = nullptr;
         m_hasEntries = false;
     }
 }
@@ skipping 910 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink