MemoryPressureMonitor: allow selecting the source of the memory measurements

Author: magomez

Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.cpp

@@ -78,6 +78,7 @@ Ref<ProcessPoolConfiguration> ProcessPoolConfiguration::copy()
     copy->m_memoryPressureHandlerConfiguration = this->m_memoryPressureHandlerConfiguration;
     copy->m_disableFontHintingForTesting = this->m_disableFontHintingForTesting;
     copy->m_serviceWorkerMemoryPressureHandlerConfiguration = this->m_serviceWorkerMemoryPressureHandlerConfiguration;
+    copy->m_memoryPressureMonitorMode = this->m_memoryPressureMonitorMode;
 #endif
 #if HAVE(AUDIT_TOKEN)
     copy->m_presentingApplicationProcessToken = this->m_presentingApplicationProcessToken;

Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.h

@@ -27,6 +27,7 @@
 
 #include "APIObject.h"
 #include "CacheModel.h"
+#include "MemoryPressureMonitor.h"
 #include "WebsiteDataStore.h"
 #include <wtf/MemoryPressureHandler.h>
 #include <wtf/ProcessID.h>
@@ -156,6 +157,9 @@ class ProcessPoolConfiguration final : public ObjectImpl<Object::Type::ProcessPo
 
     void setServiceWorkerMemoryPressureHandlerConfiguration(const MemoryPressureHandler::Configuration& configuration) { m_serviceWorkerMemoryPressureHandlerConfiguration = configuration; }
     const std::optional<MemoryPressureHandler::Configuration>& serviceWorkerMemoryPressureHandlerConfiguration() const { return m_serviceWorkerMemoryPressureHandlerConfiguration; }
+
+    void setMemoryPressureMonitorMode(WebKit::MemoryPressureMonitor::Mode mode) { m_memoryPressureMonitorMode = mode; }
+    WebKit::MemoryPressureMonitor::Mode memoryPressureMonitorMode() { return m_memoryPressureMonitorMode; }
 #endif
 
     void setTimeZoneOverride(const WTF::String& timeZoneOverride) { m_timeZoneOverride = timeZoneOverride; }
@@ -203,6 +207,7 @@ class ProcessPoolConfiguration final : public ObjectImpl<Object::Type::ProcessPo
     std::optional<MemoryPressureHandler::Configuration> m_memoryPressureHandlerConfiguration;
     bool m_disableFontHintingForTesting { false };
     std::optional<MemoryPressureHandler::Configuration> m_serviceWorkerMemoryPressureHandlerConfiguration;
+    WebKit::MemoryPressureMonitor::Mode m_memoryPressureMonitorMode { WebKit::MemoryPressureMonitor::Mode::Higher };
 #endif
 #if HAVE(AUDIT_TOKEN)
     std::optional<audit_token_t> m_presentingApplicationProcessToken;

Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp

@@ -25,12 +25,14 @@
 #include "APIProcessPoolConfiguration.h"
 #include "APIString.h"
 #include "LegacyGlobalSettings.h"
+#include "MemoryPressureMonitor.h"
 #include "NetworkProcessMessages.h"
 #include "TextChecker.h"
 #include "TextCheckerState.h"
 #include "WebAutomationSession.h"
 #include "WebKitAutomationSessionPrivate.h"
 #include "WebKitDownloadPrivate.h"
+#include "WebKitEnumTypes.h"
 #include "WebKitGeolocationManagerPrivate.h"
 #include "WebKitInitialize.h"
 #include "WebKitInjectedBundleClient.h"
@@ -134,6 +136,7 @@ enum {
     PROP_MEMORY_PRESSURE_SETTINGS,
     PROP_TIME_ZONE_OVERRIDE,
     PROP_SERVICE_WORKER_MEMORY_PRESSURE_SETTINGS,
+    PROP_MEMORY_PRESSURE_MONITOR_MODE,
     N_PROPERTIES,
 };
 
@@ -288,6 +291,7 @@ struct _WebKitWebContextPrivate {
 
     WebKitMemoryPressureSettings* memoryPressureSettings;
     WebKitMemoryPressureSettings* serviceWorkerMemoryPressureSettings;
+    WebKitMemoryPressureMonitorMode memoryPressureMonitorMode;
 
     CString timeZoneOverride;
 };
@@ -423,6 +427,9 @@ static void webkitWebContextSetProperty(GObject* object, guint propID, const GVa
             context->priv->timeZoneOverride = timeZone;
         break;
     }
+    case PROP_MEMORY_PRESSURE_MONITOR_MODE:
+        context->priv->memoryPressureMonitorMode = static_cast<WebKitMemoryPressureMonitorMode>(g_value_get_enum(value));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
     }
@@ -464,6 +471,20 @@ static void webkitWebContextConstructed(GObject* object)
         g_clear_pointer(&priv->serviceWorkerMemoryPressureSettings, webkit_memory_pressure_settings_free);
     }
 
+    switch(priv->memoryPressureMonitorMode) {
+    case WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_SYSTEM:
+        configuration.setMemoryPressureMonitorMode(MemoryPressureMonitor::Mode::System);
+        break;
+    case WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_CONTAINER:
+        configuration.setMemoryPressureMonitorMode(MemoryPressureMonitor::Mode::Container);
+        break;
+    case WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_HIGHER:
+        configuration.setMemoryPressureMonitorMode(MemoryPressureMonitor::Mode::Higher);
+        break;
+    default:
+        g_assert_not_reached();
+    }
+
 #if !ENABLE(2022_GLIB_API)
     if (!priv->websiteDataManager)
         priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new("local-storage-directory", priv->localStorageDirectory.data(), nullptr));
@@ -641,6 +662,22 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
             WEBKIT_TYPE_MEMORY_PRESSURE_SETTINGS,
             static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
+    /**
+     * WebKitWebContext:memory-pressure-mode:
+     *
+     * Which source of measurements will the MemoryPressureMonitor use to calculate the used memory.
+     *
+     * Since: 2.38
+     */
+    sObjProperties[PROP_MEMORY_PRESSURE_MONITOR_MODE] =
+        g_param_spec_enum(
+            "memory-pressure-monitor-mode",
+            _("MemoryPressureMonitor mode"),
+            _("Whether the MemoryPressureMonitor will take measures from the system memory, the container or both"),
+            WEBKIT_TYPE_MEMORY_PRESSURE_MONITOR_MODE,
+            WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_HIGHER,
+            static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+
     /**
      * WebKitWebContext:time-zone-override:
      *

Source/WebKit/UIProcess/API/glib/WebKitWebContext.h.in

@@ -120,6 +120,26 @@ typedef enum {
 } WebKitProcessModel;
 #endif
 
+/**
+ * WebKitMemoryPressureMonitorMode:
+ * @WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_SYSTEM: calculate
+ * the percentage of used memory based only on system memory polling.
+ * @WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_CONTAINER: calculate
+ * the percentage of used memory based on the usage reported by the container.
+ * @WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_HIGHER: calculate
+ * the percentage of used memory as the higher of the values reported by the
+ * the system memory and the container.
+ *
+ * Enum values used for determining the MemoryPressureMonitor source of data.
+ *
+ * Since: 2.38
+ */
+typedef enum {
+    WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_SYSTEM,
+    WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_CONTAINER,
+    WEBKIT_MEMORY_PRESSURE_MONITOR_MODE_HIGHER,
+} WebKitMemoryPressureMonitorMode;
+
 /**
  * WebKitURISchemeRequestCallback:
  * @request: the #WebKitURISchemeRequest

Source/WebKit/UIProcess/WebProcessPool.cpp

@@ -277,8 +277,10 @@ WebProcessPool::WebProcessPool(API::ProcessPoolConfiguration& configuration)
     platformInitialize(needsGlobalStaticInitialization);
 
 #if OS(LINUX)
-    if (!MemoryPressureMonitor::disabled())
+    if (!MemoryPressureMonitor::disabled()) {
+        MemoryPressureMonitor::singleton().setMode(m_configuration->memoryPressureMonitorMode());
         MemoryPressureMonitor::singleton().start();
+    }
 #endif
 
     addMessageReceiver(Messages::WebProcessPool::messageReceiverName(), *this);

Source/WebKit/UIProcess/linux/MemoryPressureMonitor.cpp

@@ -245,7 +245,7 @@ static CString getCgroupControllerPath(FILE* cgroupControllerFile, const char* c
 }
 
 
-static int systemMemoryUsedAsPercentage(FILE* memInfoFile, FILE* zoneInfoFile, CGroupMemoryController* memoryController)
+static int systemMemoryUsedAsPercentage(FILE* memInfoFile, FILE* zoneInfoFile)
 {
     if (!memInfoFile || fseek(memInfoFile, 0, SEEK_SET))
         return -1;
@@ -288,21 +288,29 @@ static int systemMemoryUsedAsPercentage(FILE* memInfoFile, FILE* zoneInfoFile, C
         return -1;
 
     int memoryUsagePercentage = ((memoryTotal - memoryAvailable) * 100) / memoryTotal;
-    LOG(MemoryPressure, "MemoryPressureMonitor::memory: real (total: %zu kB) (available: %zu kB) (usage: %d%%)", memoryTotal, memoryAvailable, memoryUsagePercentage);
-    if (memoryController->isActive()) {
-        memoryTotal = memoryController->getMemoryTotalWithCgroup();
-        size_t memoryUsage = memoryController->getMemoryUsageWithCgroup();
-        if (memoryTotal != notSet && memoryUsage != notSet) {
-            int memoryUsagePercentageWithCgroup = 100 * ((float) memoryUsage / (float) memoryTotal);
-            LOG(MemoryPressure, "MemoryPressureMonitor::memory: cgroup (total: %zu bytes) (in use: %zu bytes) (usage: %d%%)", memoryTotal, memoryUsage, memoryUsagePercentageWithCgroup);
-            if (memoryUsagePercentageWithCgroup > memoryUsagePercentage)
-                memoryUsagePercentage = memoryUsagePercentageWithCgroup;
-        }
-    }
-    LOG(MemoryPressure, "MemoryPressureMonitor::memory: (memoryUsagePercentage: %d%%)", memoryUsagePercentage);
+    LOG(MemoryPressure, "MemoryPressureMonitor: memory real (memory total=%zu kB) (memory available=%zu kB) (memory usage percentage=%d )", memoryTotal, memoryAvailable, memoryUsagePercentage);
+
     return memoryUsagePercentage;
 }
 
+static int containerMemoryUsedAsPercentage(CGroupMemoryController* memoryController)
+{
+    if (!memoryController->isActive())
+        return -1;
+
+    size_t memoryTotal = memoryController->getMemoryTotalWithCgroup();
+    size_t memoryUsage = memoryController->getMemoryUsageWithCgroup();
+
+    if (memoryTotal == notSet || memoryUsage == notSet)
+        return -1;
+
+    int memoryUsagePercentageWithCgroup = 100 * ((float) memoryUsage / (float) memoryTotal);
+    LOG(MemoryPressure, "MemoryPressureMonitor: memory cgroup (memory total=%zu bytes) (memory usage=%zu bytes) (memory usage percentage=%d bytes)", memoryTotal, memoryUsage, memoryUsagePercentageWithCgroup);
+
+    return memoryUsagePercentageWithCgroup;
+}
+
+
 static inline Seconds pollIntervalForUsedMemoryPercentage(int usedPercentage)
 {
     // Use a different poll interval depending on the currently memory used,
@@ -353,30 +361,50 @@ void MemoryPressureMonitor::start()
 
     m_started = true;
 
-    Thread::create("MemoryPressureMonitor"_s, [] {
+    Thread::create("MemoryPressureMonitor"_s, [mode = m_mode] {
         FileHandle memInfoFile, zoneInfoFile, cgroupControllerFile;
         CGroupMemoryController memoryController = CGroupMemoryController();
         Seconds pollInterval = s_maxPollingInterval;
         while (true) {
             sleep(pollInterval);
 
-            // Cannot operate without this one, retry opening on the next iteration after sleeping.
-            if (!tryOpeningForUnbufferedReading(memInfoFile, s_procMeminfo))
-                continue;
+            int usedPercentage = -1;
+            if (mode == Mode::Container || mode == Mode::Higher) {
+                tryOpeningForUnbufferedReading(cgroupControllerFile, s_procSelfCgroup);
+
+                CString cgroupMemoryControllerPath = getCgroupControllerPath(cgroupControllerFile.get(), "memory");
+                memoryController.setMemoryControllerPath(cgroupMemoryControllerPath);
+
+                usedPercentage = containerMemoryUsedAsPercentage(&memoryController);
+
+                // Warn only if we weren't able to get the data and we're in container mode, where it's
+                // expected to work.
+                if (usedPercentage == -1 && mode == Mode::Container)
+                    WTFLogAlways("MemoryPressureMonitor: failed to get the memory usage using cgroup");
+            }
 
-            // The monitor can work without these two, but it will be more precise if thy are eventually opened: keep trying.
-            tryOpeningForUnbufferedReading(zoneInfoFile, s_procZoneinfo);
-            tryOpeningForUnbufferedReading(cgroupControllerFile, s_procSelfCgroup);
+            if (mode == Mode::System || mode == Mode::Higher) {
+                // Cannot operate without this one, retry opening on the next iteration after sleeping.
+                if (!tryOpeningForUnbufferedReading(memInfoFile, s_procMeminfo))
+                    continue;
+
+                tryOpeningForUnbufferedReading(zoneInfoFile, s_procZoneinfo);
+
+                int systemUsedPercentage = systemMemoryUsedAsPercentage(memInfoFile.get(), zoneInfoFile.get());
+
+                if (systemUsedPercentage == -1)
+                    WTFLogAlways("MemoryPressureMonitor: failed to get the memory usage using real memory");
+
+                usedPercentage = std::max(usedPercentage, systemUsedPercentage);
+            }
 
-            CString cgroupMemoryControllerPath = getCgroupControllerPath(cgroupControllerFile.get(), "memory");
-            memoryController.setMemoryControllerPath(cgroupMemoryControllerPath);
-            int usedPercentage = systemMemoryUsedAsPercentage(memInfoFile.get(), zoneInfoFile.get(), &memoryController);
             if (usedPercentage == -1) {
-                WTFLogAlways("Failed to get the memory usage");
+                WTFLogAlways("MemoryPressureMonitor: failed to get the memory usage using any method");
                 pollInterval = s_maxPollingInterval;
                 continue;
             }
 
+            LOG(MemoryPressure, "MemoryPressureMonitor: memoryUsagePercentage (%d)", usedPercentage);
             if (usedPercentage >= s_memoryPresurePercentageThreshold) {
                 bool isCritical = (usedPercentage >= s_memoryPresurePercentageThresholdCritical);
                 RunLoop::main().dispatch([isCritical] {

Source/WebKit/UIProcess/linux/MemoryPressureMonitor.h

@@ -37,16 +37,24 @@ class MemoryPressureMonitor {
     WTF_MAKE_NONCOPYABLE(MemoryPressureMonitor);
     friend NeverDestroyed<MemoryPressureMonitor>;
 public:
+    enum class Mode : uint8_t {
+        System,
+        Container,
+        Higher
+    };
+
     static MemoryPressureMonitor& singleton();
     void start();
     static bool disabled();
+    void setMode(Mode mode) { m_mode = mode; }
 
     ~MemoryPressureMonitor();
 
 private:
     MemoryPressureMonitor() = default;
     bool m_started { false };
     static bool s_disabled;
+    Mode m_mode { Mode::Higher };
 };
 
 class CGroupMemoryController {