MemoryPressureMonitor.cpp [plain text]
#include "config.h"
#include "MemoryPressureMonitor.h"
#if OS(LINUX)
#include "Attachment.h"
#include <errno.h>
#include <fcntl.h>
#include <mutex>
#include <stdlib.h>
#include <string.h>
#include <sys/eventfd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <wtf/CurrentTime.h>
#include <wtf/Threading.h>
#include <wtf/UniStdExtras.h>
namespace WebKit {
static const size_t notSet = static_cast<size_t>(-1);
static const double s_minPollingIntervalInSeconds = 1;
static const double s_maxPollingIntervalInSeconds = 5;
static const double s_minUsedMemoryPercentageForPolling = 50;
static const double s_maxUsedMemoryPercentageForPolling = 90;
static const int s_memoryPresurePercentageThreshold = 95;
static size_t lowWatermarkPages()
{
FILE* file = fopen("/proc/zoneinfo", "r");
if (!file)
return notSet;
size_t low = 0;
bool inZone = false;
bool foundLow = false;
char buffer[128];
while (char* line = fgets(buffer, 128, file)) {
if (!strcmp(line, "Node")) {
inZone = true;
foundLow = false;
continue;
}
char* token = strtok(line, " ");
if (!token)
continue;
if (!strcmp(token, "low")) {
if (!inZone || foundLow) {
low = notSet;
break;
}
token = strtok(nullptr, " ");
if (!token) {
low = notSet;
break;
}
low += atoll(token);
foundLow = true;
}
}
fclose(file);
return low;
}
static inline size_t systemPageSize()
{
static size_t pageSize = 0;
if (!pageSize)
pageSize = sysconf(_SC_PAGE_SIZE);
return pageSize;
}
static size_t calculateMemoryAvailable(size_t memoryFree, size_t activeFile, size_t inactiveFile, size_t slabReclaimable)
{
if (memoryFree == notSet || activeFile == notSet || inactiveFile == notSet || slabReclaimable == notSet)
return notSet;
size_t lowWatermark = lowWatermarkPages();
if (lowWatermark == notSet)
return notSet;
lowWatermark *= systemPageSize() / KB;
lowWatermark *= systemPageSize() / KB;
size_t memoryAvailable = memoryFree - lowWatermark;
size_t pageCache = activeFile + inactiveFile;
pageCache -= std::min(pageCache / 2, lowWatermark);
memoryAvailable += pageCache;
memoryAvailable += slabReclaimable - std::min(slabReclaimable / 2, lowWatermark);
return memoryAvailable;
}
static int systemMemoryUsedAsPercentage()
{
FILE* file = fopen("/proc/meminfo", "r");
if (!file)
return -1;
size_t memoryAvailable, memoryTotal, memoryFree, activeFile, inactiveFile, slabReclaimable;
memoryAvailable = memoryTotal = memoryFree = activeFile = inactiveFile = slabReclaimable = notSet;
char buffer[128];
while (char* line = fgets(buffer, 128, file)) {
char* token = strtok(line, " ");
if (!token)
break;
if (!strcmp(token, "MemAvailable:")) {
if ((token = strtok(nullptr, " "))) {
memoryAvailable = atoll(token);
if (memoryTotal != notSet)
break;
}
} else if (!strcmp(token, "MemTotal:")) {
if ((token = strtok(nullptr, " ")))
memoryTotal = atoll(token);
else
break;
} else if (!strcmp(token, "MemFree:")) {
if ((token = strtok(nullptr, " ")))
memoryFree = atoll(token);
else
break;
} else if (!strcmp(token, "Active(file):")) {
if ((token = strtok(nullptr, " ")))
activeFile = atoll(token);
else
break;
} else if (!strcmp(token, "Inactive(file):")) {
if ((token = strtok(nullptr, " ")))
inactiveFile = atoll(token);
else
break;
} else if (!strcmp(token, "SReclaimable:")) {
if ((token = strtok(nullptr, " ")))
slabReclaimable = atoll(token);
else
break;
}
if (memoryTotal != notSet && memoryFree != notSet && activeFile != notSet && inactiveFile != notSet && slabReclaimable != notSet)
break;
}
fclose(file);
if (!memoryTotal || memoryTotal == notSet)
return -1;
if (memoryAvailable == notSet) {
memoryAvailable = calculateMemoryAvailable(memoryFree, activeFile, inactiveFile, slabReclaimable);
if (memoryAvailable == notSet)
return -1;
}
if (memoryAvailable > memoryTotal)
return -1;
return ((memoryTotal - memoryAvailable) * 100) / memoryTotal;
}
static inline double pollIntervalForUsedMemoryPercentage(int usedPercentage)
{
if (usedPercentage < s_minUsedMemoryPercentageForPolling)
return s_maxPollingIntervalInSeconds;
if (usedPercentage >= s_maxUsedMemoryPercentageForPolling)
return s_minPollingIntervalInSeconds;
return s_minPollingIntervalInSeconds + (s_maxPollingIntervalInSeconds - s_minPollingIntervalInSeconds) *
((usedPercentage - s_minUsedMemoryPercentageForPolling) / (s_maxUsedMemoryPercentageForPolling - s_minUsedMemoryPercentageForPolling));
}
static bool isSystemdMemoryPressureMonitorAvailable()
{
int fd = open("/sys/fs/cgroup/memory/memory.pressure_level", O_CLOEXEC | O_RDONLY);
if (fd == -1)
return false;
close(fd);
fd = open("/sys/fs/cgroup/memory/cgroup.event_control", O_CLOEXEC | O_WRONLY);
if (fd == -1)
return false;
close(fd);
return true;
}
bool MemoryPressureMonitor::isEnabled()
{
static std::once_flag onceFlag;
static bool enabled;
std::call_once(onceFlag, [] { enabled = !isSystemdMemoryPressureMonitorAvailable(); });
return enabled;
}
MemoryPressureMonitor& MemoryPressureMonitor::singleton()
{
ASSERT(isEnabled());
static NeverDestroyed<MemoryPressureMonitor> memoryMonitor;
return memoryMonitor;
}
MemoryPressureMonitor::MemoryPressureMonitor()
: m_eventFD(eventfd(0, EFD_CLOEXEC))
{
if (m_eventFD == -1)
return;
ThreadIdentifier threadIdentifier = createThread("MemoryPressureMonitor", [this] {
double pollInterval = s_maxPollingIntervalInSeconds;
while (true) {
sleep(pollInterval);
int usedPercentage = systemMemoryUsedAsPercentage();
if (usedPercentage >= s_memoryPresurePercentageThreshold) {
uint64_t fdEvent = 1;
ssize_t bytesWritten = write(m_eventFD, &fdEvent, sizeof(uint64_t));
if (bytesWritten != sizeof(uint64_t)) {
WTFLogAlways("Error writing to MemoryPressureMonitor eventFD: %s", strerror(errno));
break;
}
}
pollInterval = pollIntervalForUsedMemoryPercentage(usedPercentage);
}
close(m_eventFD);
});
detachThread(threadIdentifier);
}
IPC::Attachment MemoryPressureMonitor::createHandle() const
{
int duplicatedHandle = dupCloseOnExec(m_eventFD);
if (duplicatedHandle == -1)
return { };
return IPC::Attachment(duplicatedHandle);
}
}
#endif // OS(LINUX)