Changeset 211120 in webkit

Timestamp:

Jan 24, 2017, 4:15:00 PM (10 years ago)

Author:

akling@apple.com

Message:

Add memory footprint reporting using diagnostic logging.
<​https://webkit.org/b/167285>
<rdar://problem/30151767>

Reviewed by Chris Dumez.

Add some basic logging of physical memory footprint post-load and post-backgrounding.
The logging works similarly to the CPU usage logging, though with slightly longer
delays to allow the measurement to stabilize.

• page/DiagnosticLoggingKeys.cpp:

(WebCore::DiagnosticLoggingKeys::memoryUsageKey):
(WebCore::DiagnosticLoggingKeys::memoryUsageToDiagnosticLoggingKey):

• page/DiagnosticLoggingKeys.h:
• page/PerformanceLogging.cpp:

(WebCore::PerformanceLogging::physicalFootprint):

• page/PerformanceLogging.h:
• page/PerformanceMonitor.cpp:

(WebCore::PerformanceMonitor::PerformanceMonitor):
(WebCore::PerformanceMonitor::didFinishLoad):
(WebCore::PerformanceMonitor::activityStateChanged):
(WebCore::PerformanceMonitor::measurePostLoadMemoryUsage):
(WebCore::PerformanceMonitor::measurePostBackgroundingMemoryUsage):

• page/PerformanceMonitor.h:
• page/Settings.h:

(WebCore::Settings::isPostLoadMemoryUsageMeasurementEnabled):
(WebCore::Settings::isPostBackgroundingMemoryUsageMeasurementEnabled):

• page/cocoa/PerformanceLoggingCocoa.mm:

(WebCore::PerformanceLogging::physicalFootprint):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/DiagnosticLoggingKeys.cpp (modified) (2 diffs)
• page/DiagnosticLoggingKeys.h (modified) (2 diffs)
• page/PerformanceLogging.cpp (modified) (1 diff)
• page/PerformanceLogging.h (modified) (1 diff)
• page/PerformanceMonitor.cpp (modified) (7 diffs)
• page/PerformanceMonitor.h (modified) (2 diffs)
• page/Settings.h (modified) (2 diffs)
• page/cocoa/PerformanceLoggingCocoa.mm (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-01-24  Andreas Kling  <akling@apple.com>
+
+        Add memory footprint reporting using diagnostic logging.
+        <https://webkit.org/b/167285>
+        <rdar://problem/30151767>
+
+        Reviewed by Chris Dumez.
+
+        Add some basic logging of physical memory footprint post-load and post-backgrounding.
+        The logging works similarly to the CPU usage logging, though with slightly longer
+        delays to allow the measurement to stabilize.
+
+        * page/DiagnosticLoggingKeys.cpp:
+        (WebCore::DiagnosticLoggingKeys::memoryUsageKey):
+        (WebCore::DiagnosticLoggingKeys::memoryUsageToDiagnosticLoggingKey):
+        * page/DiagnosticLoggingKeys.h:
+        * page/PerformanceLogging.cpp:
+        (WebCore::PerformanceLogging::physicalFootprint):
+        * page/PerformanceLogging.h:
+        * page/PerformanceMonitor.cpp:
+        (WebCore::PerformanceMonitor::PerformanceMonitor):
+        (WebCore::PerformanceMonitor::didFinishLoad):
+        (WebCore::PerformanceMonitor::activityStateChanged):
+        (WebCore::PerformanceMonitor::measurePostLoadMemoryUsage):
+        (WebCore::PerformanceMonitor::measurePostBackgroundingMemoryUsage):
+        * page/PerformanceMonitor.h:
+        * page/Settings.h:
+        (WebCore::Settings::isPostLoadMemoryUsageMeasurementEnabled):
+        (WebCore::Settings::isPostBackgroundingMemoryUsageMeasurementEnabled):
+        * page/cocoa/PerformanceLoggingCocoa.mm:
+        (WebCore::PerformanceLogging::physicalFootprint):
+
 2017-01-24  Joseph Pecoraro  <pecoraro@apple.com>
 

trunk/Source/WebCore/page/DiagnosticLoggingKeys.cpp

@@ -329 +329 @@
 }
 
+String DiagnosticLoggingKeys::memoryUsageKey()
+{
+    return ASCIILiteral("memoryUsage");
+}
+
 String DiagnosticLoggingKeys::createSharedBufferFailedKey()
 {
@@ -672 +677 @@
 {
     return ASCIILiteral("webGL");
+}
+
+String DiagnosticLoggingKeys::memoryUsageToDiagnosticLoggingKey(uint64_t memoryUsage)
+{
+    if (memoryUsage < 32 * MB)
+        return ASCIILiteral("below32");
+    if (memoryUsage < 64 * MB)
+        return ASCIILiteral("32to64");
+    if (memoryUsage < 128 * MB)
+        return ASCIILiteral("64to128");
+    if (memoryUsage < 256 * MB)
+        return ASCIILiteral("128to256");
+    if (memoryUsage < 512 * MB)
+        return ASCIILiteral("256to512");
+    if (memoryUsage < 1024 * MB)
+        return ASCIILiteral("512to1024");
+    if (memoryUsage < 2048 * MB)
+        return ASCIILiteral("1024to2048");
+    if (memoryUsage < 4096llu * MB)
+        return ASCIILiteral("2048to4096");
+    if (memoryUsage < 8192llu * MB)
+        return ASCIILiteral("4096to8192");
+    if (memoryUsage < 16384llu * MB)
+        return ASCIILiteral("8192to16384");
+    if (memoryUsage < 32768llu * MB)
+        return ASCIILiteral("16384to32768");
+    return ASCIILiteral("over32768");
 }
 

trunk/Source/WebCore/page/DiagnosticLoggingKeys.h

@@ -42 +42 @@
     static String cannotSuspendActiveDOMObjectsKey();
     WEBCORE_EXPORT static String cpuUsageKey();
+    WEBCORE_EXPORT static String memoryUsageKey();
     WEBCORE_EXPORT static String createSharedBufferFailedKey();
     WEBCORE_EXPORT static String deltaKey();
@@ -160 +161 @@
     WEBCORE_EXPORT static String zoomedKey();
 
+    WEBCORE_EXPORT static String memoryUsageToDiagnosticLoggingKey(uint64_t memoryUsage);
     WEBCORE_EXPORT static String foregroundCPUUsageToDiagnosticLoggingKey(double cpuUsage);
     WEBCORE_EXPORT static String backgroundCPUUsageToDiagnosticLoggingKey(double cpuUsage);

trunk/Source/WebCore/page/PerformanceLogging.cpp

@@ -104 +104 @@
 #if !PLATFORM(COCOA)
 void PerformanceLogging::getPlatformMemoryUsageStatistics(HashMap<const char*, size_t>&) { }
+std::optional<uint64_t> PerformanceLogging::physicalFootprint() { return std::nullopt; }
 #endif
 

trunk/Source/WebCore/page/PerformanceLogging.h

@@ -50 +50 @@
     WEBCORE_EXPORT static HashCountedSet<const char*> javaScriptObjectCounts();
     WEBCORE_EXPORT static HashMap<const char*, size_t> memoryUsageStatistics(ShouldIncludeExpensiveComputations);
+    WEBCORE_EXPORT static std::optional<uint64_t> physicalFootprint();
 
 private:

trunk/Source/WebCore/page/PerformanceMonitor.cpp

@@ -33 +33 @@
 #include "Logging.h"
 #include "Page.h"
+#include "PerformanceLogging.h"
 #include "Settings.h"
 
@@ -43 +44 @@
 static const std::chrono::minutes backgroundCPUUsageMeasurementDuration { 5 };
 static const std::chrono::minutes cpuUsageSamplingInterval { 10 };
+
+static const std::chrono::seconds memoryUsageMeasurementDelay { 10 };
 
 static inline ActivityStateForCPUSampling activityStateForCPUSampling(ActivityState::Flags state)
@@ -58 +61 @@
     , m_postBackgroundingCPUUsageTimer(*this, &PerformanceMonitor::measurePostBackgroundingCPUUsage)
     , m_perActivityStateCPUUsageTimer(*this, &PerformanceMonitor::measurePerActivityStateCPUUsage)
+    , m_postPageLoadMemoryUsageTimer(*this, &PerformanceMonitor::measurePostLoadMemoryUsage)
+    , m_postBackgroundingMemoryUsageTimer(*this, &PerformanceMonitor::measurePostBackgroundingMemoryUsage)
 {
     ASSERT(!page.isUtilityPage());
@@ -71 +76 @@
     m_postLoadCPUTime = std::nullopt;
     m_postPageLoadCPUUsageTimer.stop();
+    m_postPageLoadMemoryUsageTimer.stop();
 }
 
@@ -80 +86 @@
         m_postPageLoadCPUUsageTimer.startOneShot(cpuUsageMeasurementDelay);
     }
+
+    // Likewise for post-load memory usage measurement.
+    if (Settings::isPostLoadMemoryUsageMeasurementEnabled() && m_page.isOnlyNonUtilityPage())
+        m_postPageLoadMemoryUsageTimer.startOneShot(memoryUsageMeasurementDelay);
 }
 
@@ -104 +114 @@
         }
     }
+
+    if (Settings::isPostBackgroundingMemoryUsageMeasurementEnabled() && visibilityChanged) {
+        if (newState & ActivityState::IsVisible)
+            m_postBackgroundingMemoryUsageTimer.stop();
+        else if (m_page.isOnlyNonUtilityPage())
+            m_postBackgroundingMemoryUsageTimer.startOneShot(memoryUsageMeasurementDelay);
+    }
 }
 
@@ -126 +143 @@
     RELEASE_LOG_IF_ALLOWED(PerformanceLogging, "measurePostLoadCPUUsage: Process was using %.1f%% CPU after the page load.", cpuUsage);
     m_page.diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::postPageLoadKey(), DiagnosticLoggingKeys::cpuUsageKey(), DiagnosticLoggingKeys::foregroundCPUUsageToDiagnosticLoggingKey(cpuUsage), ShouldSample::No);
+}
+
+void PerformanceMonitor::measurePostLoadMemoryUsage()
+{
+    if (!m_page.isOnlyNonUtilityPage())
+        return;
+
+    std::optional<uint64_t> memoryUsage = PerformanceLogging::physicalFootprint();
+    if (!memoryUsage)
+        return;
+
+    RELEASE_LOG_IF_ALLOWED(PerformanceLogging, "measurePostLoadMemoryUsage: Process was using %llu bytes of memory after the page load.", memoryUsage.value());
+    m_page.diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::postPageLoadKey(), DiagnosticLoggingKeys::memoryUsageKey(), DiagnosticLoggingKeys::memoryUsageToDiagnosticLoggingKey(memoryUsage.value()), ShouldSample::No);
+}
+
+void PerformanceMonitor::measurePostBackgroundingMemoryUsage()
+{
+    if (!m_page.isOnlyNonUtilityPage())
+        return;
+
+    std::optional<uint64_t> memoryUsage = PerformanceLogging::physicalFootprint();
+    if (!memoryUsage)
+        return;
+
+    RELEASE_LOG_IF_ALLOWED(PerformanceLogging, "measurePostBackgroundingMemoryUsage: Process was using %llu bytes of memory after becoming non visible.", memoryUsage.value());
+    m_page.diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::postPageBackgroundingKey(), DiagnosticLoggingKeys::memoryUsageKey(), DiagnosticLoggingKeys::memoryUsageToDiagnosticLoggingKey(memoryUsage.value()), ShouldSample::No);
 }
 

trunk/Source/WebCore/page/PerformanceMonitor.h

@@ -49 +49 @@
     void measureCPUUsageInActivityState(ActivityStateForCPUSampling);
 
+    void measurePostLoadMemoryUsage();
+    void measurePostBackgroundingMemoryUsage();
+
     Page& m_page;
 
@@ -57 +60 @@
     Timer m_perActivityStateCPUUsageTimer;
     std::optional<CPUTime> m_perActivityStateCPUTime;
+
+    Timer m_postPageLoadMemoryUsageTimer;
+    Timer m_postBackgroundingMemoryUsageTimer;
 };
 

trunk/Source/WebCore/page/Settings.h

@@ -204 +204 @@
     static bool isPerActivityStateCPUUsageMeasurementEnabled();
 
+    static bool isPostLoadMemoryUsageMeasurementEnabled();
+    static bool isPostBackgroundingMemoryUsageMeasurementEnabled();
+
     static bool globalConstRedeclarationShouldThrow();
 
@@ -452 +455 @@
 }
 
+inline bool Settings::isPostLoadMemoryUsageMeasurementEnabled()
+{
+#if PLATFORM(COCOA)
+    return true;
+#else
+    return false;
+#endif
+}
+
+inline bool Settings::isPostBackgroundingMemoryUsageMeasurementEnabled()
+{
+#if PLATFORM(MAC)
+    return true;
+#else
+    return false;
+#endif
+}
+
 } // namespace WebCore

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

@@ -32 +32 @@
 namespace WebCore {
 
+std::optional<uint64_t> PerformanceLogging::physicalFootprint()
+{
+    task_vm_info_data_t vmInfo;
+    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
+    kern_return_t result = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
+    if (result != KERN_SUCCESS)
+        return std::nullopt;
+    return vmInfo.phys_footprint;
+}
+
 void PerformanceLogging::getPlatformMemoryUsageStatistics(HashMap<const char*, size_t>& stats)
 {