MemoryPressureHandler.h [plain text]
#pragma once
#include <atomic>
#include <ctime>
#include <wtf/FastMalloc.h>
#include <wtf/Forward.h>
#include <wtf/Function.h>
#include <wtf/Optional.h>
#include <wtf/RunLoop.h>
#if OS(WINDOWS)
#include <wtf/win/Win32Handle.h>
#endif
namespace WTF {
enum class MemoryUsagePolicy : uint8_t {
Unrestricted, Conservative, Strict, };
enum class WebsamProcessState : uint8_t {
Active,
Inactive,
};
enum class Critical : uint8_t { No, Yes };
enum class Synchronous : uint8_t { No, Yes };
typedef WTF::Function<void(Critical, Synchronous)> LowMemoryHandler;
class MemoryPressureHandler {
WTF_MAKE_FAST_ALLOCATED;
friend class WTF::LazyNeverDestroyed<MemoryPressureHandler>;
public:
WTF_EXPORT_PRIVATE static MemoryPressureHandler& singleton();
WTF_EXPORT_PRIVATE void install();
WTF_EXPORT_PRIVATE void setShouldUsePeriodicMemoryMonitor(bool);
#if OS(LINUX) || OS(FREEBSD)
WTF_EXPORT_PRIVATE void triggerMemoryPressureEvent(bool isCritical);
#endif
void setMemoryKillCallback(WTF::Function<void()>&& function) { m_memoryKillCallback = WTFMove(function); }
void setMemoryPressureStatusChangedCallback(WTF::Function<void(bool)>&& function) { m_memoryPressureStatusChangedCallback = WTFMove(function); }
void setDidExceedInactiveLimitWhileActiveCallback(WTF::Function<void()>&& function) { m_didExceedInactiveLimitWhileActiveCallback = WTFMove(function); }
void setLowMemoryHandler(LowMemoryHandler&& handler)
{
m_lowMemoryHandler = WTFMove(handler);
}
bool isUnderMemoryPressure() const
{
return m_underMemoryPressure
#if PLATFORM(MAC)
|| m_memoryUsagePolicy >= MemoryUsagePolicy::Strict
#endif
|| m_isSimulatingMemoryPressure;
}
void setUnderMemoryPressure(bool);
WTF_EXPORT_PRIVATE static MemoryUsagePolicy currentMemoryUsagePolicy();
#if PLATFORM(COCOA)
WTF_EXPORT_PRIVATE void setDispatchQueue(dispatch_queue_t);
#endif
class ReliefLogger {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit ReliefLogger(const char *log)
: m_logString(log)
, m_initialMemory(loggingEnabled() ? platformMemoryUsage() : MemoryUsage { })
{
}
~ReliefLogger()
{
if (loggingEnabled())
logMemoryUsageChange();
}
const char* logString() const { return m_logString; }
static void setLoggingEnabled(bool enabled) { s_loggingEnabled = enabled; }
static bool loggingEnabled()
{
#if RELEASE_LOG_DISABLED
return s_loggingEnabled;
#else
return true;
#endif
}
private:
struct MemoryUsage {
WTF_MAKE_STRUCT_FAST_ALLOCATED;
MemoryUsage() = default;
MemoryUsage(size_t resident, size_t physical)
: resident(resident)
, physical(physical)
{
}
size_t resident { 0 };
size_t physical { 0 };
};
Optional<MemoryUsage> platformMemoryUsage();
void logMemoryUsageChange();
const char* m_logString;
Optional<MemoryUsage> m_initialMemory;
WTF_EXPORT_PRIVATE static bool s_loggingEnabled;
};
WTF_EXPORT_PRIVATE void releaseMemory(Critical, Synchronous = Synchronous::No);
WTF_EXPORT_PRIVATE void beginSimulatedMemoryPressure();
WTF_EXPORT_PRIVATE void endSimulatedMemoryPressure();
WTF_EXPORT_PRIVATE void setProcessState(WebsamProcessState);
WebsamProcessState processState() const { return m_processState; }
WTF_EXPORT_PRIVATE static void setPageCount(unsigned);
void setShouldLogMemoryMemoryPressureEvents(bool shouldLog) { m_shouldLogMemoryMemoryPressureEvents = shouldLog; }
private:
size_t thresholdForMemoryKill();
void memoryPressureStatusChanged();
void uninstall();
void holdOff(Seconds);
MemoryPressureHandler();
~MemoryPressureHandler() = delete;
void respondToMemoryPressure(Critical, Synchronous = Synchronous::No);
void platformReleaseMemory(Critical);
void platformInitialize();
void measurementTimerFired();
void shrinkOrDie();
void setMemoryUsagePolicyBasedOnFootprint(size_t);
void doesExceedInactiveLimitWhileActive();
void doesNotExceedInactiveLimitWhileActive();
unsigned m_pageCount { 0 };
std::atomic<bool> m_underMemoryPressure { false };
bool m_installed { false };
bool m_isSimulatingMemoryPressure { false };
bool m_shouldLogMemoryMemoryPressureEvents { true };
bool m_hasInvokedDidExceedInactiveLimitWhileActiveCallback { false };
WebsamProcessState m_processState { WebsamProcessState::Inactive };
MemoryUsagePolicy m_memoryUsagePolicy { MemoryUsagePolicy::Unrestricted };
std::unique_ptr<RunLoop::Timer<MemoryPressureHandler>> m_measurementTimer;
WTF::Function<void()> m_memoryKillCallback;
WTF::Function<void(bool)> m_memoryPressureStatusChangedCallback;
WTF::Function<void()> m_didExceedInactiveLimitWhileActiveCallback;
LowMemoryHandler m_lowMemoryHandler;
#if OS(WINDOWS)
void windowsMeasurementTimerFired();
RunLoop::Timer<MemoryPressureHandler> m_windowsMeasurementTimer;
Win32Handle m_lowMemoryHandle;
#endif
#if OS(LINUX) || OS(FREEBSD)
RunLoop::Timer<MemoryPressureHandler> m_holdOffTimer;
void holdOffTimerFired();
#endif
#if PLATFORM(COCOA)
dispatch_queue_t m_dispatchQueue { nullptr };
#endif
};
extern WTFLogChannel LogMemoryPressure;
}
using WTF::Critical;
using WTF::MemoryPressureHandler;
using WTF::Synchronous;
using WTF::WebsamProcessState;