Changeset 192595 in webkit

Timestamp:

Nov 18, 2015, 3:48:48 PM (10 years ago)

Author:

akling@apple.com

Message:

ResourceUsageOverlay should have better accounting for reclaimable memory.
<​https://webkit.org/b/151407>

Reviewed by Anders Carlsson.

Add code to inspect the purgeable state of VM regions when traversing the
web process VM map, and track reclaimable regions of memory separately.

Memory categories that have some amount of reclaimable memory are now
displayed with the reclaimable amount in brackets, e.g "123.45 MB [56.78MB]"

• page/ResourceUsageOverlay.h:
• page/cocoa/ResourceUsageOverlayCocoa.mm:

(WebCore::ResourceUsageOverlay::platformDraw):
(WebCore::TagInfo::TagInfo):
(WebCore::pagesPerVMTag):
(WebCore::runSamplerThread):
(WebCore::dirtyPagesPerVMTag): Deleted.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/ResourceUsageOverlay.h (modified) (1 diff)
• page/cocoa/ResourceUsageOverlayCocoa.mm (modified) (7 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-11-18  Andreas Kling  <akling@apple.com>
+
+        ResourceUsageOverlay should have better accounting for reclaimable memory.
+        <https://webkit.org/b/151407>
+
+        Reviewed by Anders Carlsson.
+
+        Add code to inspect the purgeable state of VM regions when traversing the
+        web process VM map, and track reclaimable regions of memory separately.
+
+        Memory categories that have some amount of reclaimable memory are now
+        displayed with the reclaimable amount in brackets, e.g "123.45 MB [56.78MB]"
+
+        * page/ResourceUsageOverlay.h:
+        * page/cocoa/ResourceUsageOverlayCocoa.mm:
+        (WebCore::ResourceUsageOverlay::platformDraw):
+        (WebCore::TagInfo::TagInfo):
+        (WebCore::pagesPerVMTag):
+        (WebCore::runSamplerThread):
+        (WebCore::dirtyPagesPerVMTag): Deleted.
+
 2015-11-18  Joseph Pecoraro  <pecoraro@apple.com>
 

trunk/Source/WebCore/page/ResourceUsageOverlay.h

@@ -82 +82 @@
 #endif
 
-    static const int normalWidth = 550;
+    static const int normalWidth = 570;
     static const int normalHeight = 130;
 };

trunk/Source/WebCore/page/cocoa/ResourceUsageOverlayCocoa.mm

@@ -147 +147 @@
     RetainPtr<CGColorRef> color;
     RingBuffer<size_t> history;
+    RingBuffer<size_t> reclaimableHistory;
     bool isSubcategory { false };
     unsigned type { MemoryCategory::NumberOfCategories };
@@ -412 +413 @@
     float y = 50;
     for (auto& category : data.categories) {
+        String label = String::format("% 11s: %s", category.name.ascii().data(), formatByteNumber(category.history.last()).ascii().data());
+        size_t reclaimable = category.reclaimableHistory.last();
+        if (reclaimable)
+            label = label + String::format(" [%s]", formatByteNumber(reclaimable).ascii().data());
+
         // FIXME: Show size/capacity of GC heap.
-        showText(context, 10, y, category.color.get(), String::format("% 11s: %s", category.name.ascii().data(), formatByteNumber(category.history.last()).ascii().data()));
+        showText(context, 10, y, category.color.get(), label);
         y += 10;
     }
@@ -425 +431 @@
 }
 
-static std::array<size_t, 256> dirtyPagesPerVMTag()
-{
-    std::array<size_t, 256> dirty;
-    dirty.fill(0);
+struct TagInfo {
+    TagInfo() { }
+    size_t dirty { 0 };
+    size_t reclaimable { 0 };
+};
+
+static std::array<TagInfo, 256> pagesPerVMTag()
+{
+    std::array<TagInfo, 256> tags;
     task_t task = mach_task_self();
     mach_vm_size_t size;
@@ -435 +446 @@
     mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;
     for (mach_vm_address_t addr = 0; ; addr += size) {
+        int purgeableState;
+        if (mach_vm_purgable_control(task, addr, VM_PURGABLE_GET_STATE, &purgeableState) != KERN_SUCCESS)
+            purgeableState = VM_PURGABLE_DENY;
+
         kern_return_t kr = mach_vm_region_recurse(task, &addr, &size, &depth, (vm_region_info_t)&info, &count);
         if (kr != KERN_SUCCESS)
             break;
-        dirty[info.user_tag] += info.pages_dirtied;
-    }
-    return dirty;
+
+        if (purgeableState == VM_PURGABLE_VOLATILE) {
+            tags[info.user_tag].reclaimable += info.pages_resident;
+            continue;
+        }
+
+        if (purgeableState == VM_PURGABLE_EMPTY) {
+            static size_t vmPageSize = getpagesize();
+            tags[info.user_tag].reclaimable += size / vmPageSize;
+            continue;
+        }
+
+        bool anonymous = !info.external_pager;
+        if (anonymous) {
+            tags[info.user_tag].dirty += info.pages_resident - info.pages_reusable;
+            tags[info.user_tag].reclaimable += info.pages_reusable;
+        } else
+            tags[info.user_tag].dirty += info.pages_dirtied;
+    }
+
+    return tags;
 }
 
@@ -505 +538 @@
     while (1) {
         float cpu = cpuUsage();
-        auto dirtyPages = dirtyPagesPerVMTag();
+        auto tags = pagesPerVMTag();
         Vector<CALayer *, 8> layers;
 
@@ -512 +545 @@
             data.cpuHistory.append(cpu);
 
-            std::array<size_t, MemoryCategory::NumberOfCategories> dirtyPagesPerCategory;
-            dirtyPagesPerCategory.fill(0);
+            std::array<TagInfo, MemoryCategory::NumberOfCategories> pagesPerCategory;
 
             size_t totalDirtyPages = 0;
             for (unsigned i = 0; i < 256; ++i) {
-                dirtyPagesPerCategory[categoryForVMTag(i)] += dirtyPages[i];
-                totalDirtyPages += dirtyPages[i];
+                pagesPerCategory[categoryForVMTag(i)].dirty += tags[i].dirty;
+                pagesPerCategory[categoryForVMTag(i)].reclaimable += tags[i].reclaimable;
+                totalDirtyPages += tags[i].dirty;
             }
 
@@ -524 +557 @@
                 if (category.isSubcategory) // Only do automatic tallying for top-level categories.
                     continue;
-                category.history.append(dirtyPagesPerCategory[category.type] * vmPageSize);
+                category.history.append(pagesPerCategory[category.type].dirty * vmPageSize);
+                category.reclaimableHistory.append(pagesPerCategory[category.type].reclaimable * vmPageSize);
             }
             data.totalDirty.append(totalDirtyPages * vmPageSize);