summaryrefslogtreecommitdiffstats
path: root/xpcom/base/AvailableMemoryTracker.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'xpcom/base/AvailableMemoryTracker.cpp')
-rw-r--r--xpcom/base/AvailableMemoryTracker.cpp447
1 files changed, 447 insertions, 0 deletions
diff --git a/xpcom/base/AvailableMemoryTracker.cpp b/xpcom/base/AvailableMemoryTracker.cpp
new file mode 100644
index 000000000..6272d89cf
--- /dev/null
+++ b/xpcom/base/AvailableMemoryTracker.cpp
@@ -0,0 +1,447 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/AvailableMemoryTracker.h"
+
+#if defined(XP_WIN)
+#include "prinrval.h"
+#include "prenv.h"
+#include "nsIMemoryReporter.h"
+#include "nsMemoryPressure.h"
+#endif
+
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIRunnable.h"
+#include "nsISupports.h"
+#include "nsThreadUtils.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+
+#if defined(XP_WIN)
+# include "nsWindowsDllInterceptor.h"
+# include <windows.h>
+#endif
+
+#if defined(MOZ_MEMORY)
+# include "mozmemory.h"
+#endif // MOZ_MEMORY
+
+using namespace mozilla;
+
+namespace {
+
+#if defined(_M_IX86) && defined(XP_WIN)
+
+
+uint32_t sLowVirtualMemoryThreshold = 0;
+uint32_t sLowCommitSpaceThreshold = 0;
+uint32_t sLowPhysicalMemoryThreshold = 0;
+uint32_t sLowMemoryNotificationIntervalMS = 0;
+
+Atomic<uint32_t> sNumLowVirtualMemEvents;
+Atomic<uint32_t> sNumLowCommitSpaceEvents;
+Atomic<uint32_t> sNumLowPhysicalMemEvents;
+
+WindowsDllInterceptor sKernel32Intercept;
+WindowsDllInterceptor sGdi32Intercept;
+
+// Has Init() been called?
+bool sInitialized = false;
+
+// Has Activate() been called? The hooks don't do anything until this happens.
+bool sHooksActive = false;
+
+// Alas, we'd like to use mozilla::TimeStamp, but we can't, because it acquires
+// a lock!
+volatile bool sHasScheduledOneLowMemoryNotification = false;
+volatile PRIntervalTime sLastLowMemoryNotificationTime;
+
+// These are function pointers to the functions we wrap in Init().
+
+void* (WINAPI* sVirtualAllocOrig)(LPVOID aAddress, SIZE_T aSize,
+ DWORD aAllocationType, DWORD aProtect);
+
+void* (WINAPI* sMapViewOfFileOrig)(HANDLE aFileMappingObject,
+ DWORD aDesiredAccess, DWORD aFileOffsetHigh,
+ DWORD aFileOffsetLow, SIZE_T aNumBytesToMap);
+
+HBITMAP(WINAPI* sCreateDIBSectionOrig)(HDC aDC, const BITMAPINFO* aBitmapInfo,
+ UINT aUsage, VOID** aBits,
+ HANDLE aSection, DWORD aOffset);
+
+/**
+ * Fire a memory pressure event if it's been long enough since the last one we
+ * fired.
+ */
+bool
+MaybeScheduleMemoryPressureEvent()
+{
+ // If this interval rolls over, we may fire an extra memory pressure
+ // event, but that's not a big deal.
+ PRIntervalTime interval = PR_IntervalNow() - sLastLowMemoryNotificationTime;
+ if (sHasScheduledOneLowMemoryNotification &&
+ PR_IntervalToMilliseconds(interval) < sLowMemoryNotificationIntervalMS) {
+
+ return false;
+ }
+
+ // There's a bit of a race condition here, since an interval may be a
+ // 64-bit number, and 64-bit writes aren't atomic on x86-32. But let's
+ // not worry about it -- the races only happen when we're already
+ // experiencing memory pressure and firing notifications, so the worst
+ // thing that can happen is that we fire two notifications when we
+ // should have fired only one.
+ sHasScheduledOneLowMemoryNotification = true;
+ sLastLowMemoryNotificationTime = PR_IntervalNow();
+
+ NS_DispatchEventualMemoryPressure(MemPressure_New);
+ return true;
+}
+
+void
+CheckMemAvailable()
+{
+ if (!sHooksActive) {
+ return;
+ }
+
+ MEMORYSTATUSEX stat;
+ stat.dwLength = sizeof(stat);
+ bool success = GlobalMemoryStatusEx(&stat);
+
+ if (success) {
+ // sLowVirtualMemoryThreshold is in MB, but ullAvailVirtual is in bytes.
+ if (stat.ullAvailVirtual < sLowVirtualMemoryThreshold * 1024 * 1024) {
+ // If we're running low on virtual memory, unconditionally schedule the
+ // notification. We'll probably crash if we run out of virtual memory,
+ // so don't worry about firing this notification too often.
+ ++sNumLowVirtualMemEvents;
+ NS_DispatchEventualMemoryPressure(MemPressure_New);
+ } else if (stat.ullAvailPageFile < sLowCommitSpaceThreshold * 1024 * 1024) {
+ if (MaybeScheduleMemoryPressureEvent()) {
+ ++sNumLowCommitSpaceEvents;
+ }
+ } else if (stat.ullAvailPhys < sLowPhysicalMemoryThreshold * 1024 * 1024) {
+ if (MaybeScheduleMemoryPressureEvent()) {
+ ++sNumLowPhysicalMemEvents;
+ }
+ }
+ }
+}
+
+LPVOID WINAPI
+VirtualAllocHook(LPVOID aAddress, SIZE_T aSize,
+ DWORD aAllocationType,
+ DWORD aProtect)
+{
+ // It's tempting to see whether we have enough free virtual address space for
+ // this allocation and, if we don't, synchronously fire a low-memory
+ // notification to free some before we allocate.
+ //
+ // Unfortunately that doesn't work, principally because code doesn't expect a
+ // call to malloc could trigger a GC (or call into the other routines which
+ // are triggered by a low-memory notification).
+ //
+ // I think the best we can do here is try to allocate the memory and check
+ // afterwards how much free virtual address space we have. If we're running
+ // low, we schedule a low-memory notification to run as soon as possible.
+
+ LPVOID result = sVirtualAllocOrig(aAddress, aSize, aAllocationType, aProtect);
+
+ // Don't call CheckMemAvailable for MEM_RESERVE if we're not tracking low
+ // virtual memory. Similarly, don't call CheckMemAvailable for MEM_COMMIT if
+ // we're not tracking low physical memory.
+ if ((sLowVirtualMemoryThreshold != 0 && aAllocationType & MEM_RESERVE) ||
+ (sLowPhysicalMemoryThreshold != 0 && aAllocationType & MEM_COMMIT)) {
+ CheckMemAvailable();
+ }
+
+ return result;
+}
+
+LPVOID WINAPI
+MapViewOfFileHook(HANDLE aFileMappingObject,
+ DWORD aDesiredAccess,
+ DWORD aFileOffsetHigh,
+ DWORD aFileOffsetLow,
+ SIZE_T aNumBytesToMap)
+{
+ LPVOID result = sMapViewOfFileOrig(aFileMappingObject, aDesiredAccess,
+ aFileOffsetHigh, aFileOffsetLow,
+ aNumBytesToMap);
+ CheckMemAvailable();
+ return result;
+}
+
+HBITMAP WINAPI
+CreateDIBSectionHook(HDC aDC,
+ const BITMAPINFO* aBitmapInfo,
+ UINT aUsage,
+ VOID** aBits,
+ HANDLE aSection,
+ DWORD aOffset)
+{
+ // There are a lot of calls to CreateDIBSection, so we make some effort not
+ // to CheckMemAvailable() for calls to CreateDIBSection which allocate only
+ // a small amount of memory.
+
+ // If aSection is non-null, CreateDIBSection won't allocate any new memory.
+ bool doCheck = false;
+ if (sHooksActive && !aSection && aBitmapInfo) {
+ uint16_t bitCount = aBitmapInfo->bmiHeader.biBitCount;
+ if (bitCount == 0) {
+ // MSDN says bitCount == 0 means that it figures out how many bits each
+ // pixel gets by examining the corresponding JPEG or PNG data. We'll just
+ // assume the worst.
+ bitCount = 32;
+ }
+
+ // |size| contains the expected allocation size in *bits*. Height may be
+ // negative (indicating the direction the DIB is drawn in), so we take the
+ // absolute value.
+ int64_t size = bitCount * aBitmapInfo->bmiHeader.biWidth *
+ aBitmapInfo->bmiHeader.biHeight;
+ if (size < 0) {
+ size *= -1;
+ }
+
+ // If we're allocating more than 1MB, check how much memory is left after
+ // the allocation.
+ if (size > 1024 * 1024 * 8) {
+ doCheck = true;
+ }
+ }
+
+ HBITMAP result = sCreateDIBSectionOrig(aDC, aBitmapInfo, aUsage, aBits,
+ aSection, aOffset);
+
+ if (doCheck) {
+ CheckMemAvailable();
+ }
+
+ return result;
+}
+
+static int64_t
+LowMemoryEventsVirtualDistinguishedAmount()
+{
+ return sNumLowVirtualMemEvents;
+}
+
+static int64_t
+LowMemoryEventsPhysicalDistinguishedAmount()
+{
+ return sNumLowPhysicalMemEvents;
+}
+
+class LowEventsReporter final : public nsIMemoryReporter
+{
+ ~LowEventsReporter() {}
+
+public:
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) override
+ {
+ MOZ_COLLECT_REPORT(
+ "low-memory-events/virtual", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
+ LowMemoryEventsVirtualDistinguishedAmount(),
+"Number of low-virtual-memory events fired since startup. We fire such an "
+"event if we notice there is less than memory.low_virtual_mem_threshold_mb of "
+"virtual address space available (if zero, this behavior is disabled). The "
+"process will probably crash if it runs out of virtual address space, so "
+"this event is dire.");
+
+ MOZ_COLLECT_REPORT(
+ "low-memory-events/commit-space", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
+ sNumLowCommitSpaceEvents,
+"Number of low-commit-space events fired since startup. We fire such an "
+"event if we notice there is less than memory.low_commit_space_threshold_mb of "
+"commit space available (if zero, this behavior is disabled). Windows will "
+"likely kill the process if it runs out of commit space, so this event is "
+"dire.");
+
+ MOZ_COLLECT_REPORT(
+ "low-memory-events/physical", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
+ LowMemoryEventsPhysicalDistinguishedAmount(),
+"Number of low-physical-memory events fired since startup. We fire such an "
+"event if we notice there is less than memory.low_physical_memory_threshold_mb "
+"of physical memory available (if zero, this behavior is disabled). The "
+"machine will start to page if it runs out of physical memory. This may "
+"cause it to run slowly, but it shouldn't cause it to crash.");
+
+ return NS_OK;
+ }
+};
+NS_IMPL_ISUPPORTS(LowEventsReporter, nsIMemoryReporter)
+
+#endif // defined(_M_IX86) && defined(XP_WIN)
+
+/**
+ * This runnable is executed in response to a memory-pressure event; we spin
+ * the event-loop when receiving the memory-pressure event in the hope that
+ * other observers will synchronously free some memory that we'll be able to
+ * purge here.
+ */
+class nsJemallocFreeDirtyPagesRunnable final : public nsIRunnable
+{
+ ~nsJemallocFreeDirtyPagesRunnable() {}
+
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIRUNNABLE
+};
+
+NS_IMPL_ISUPPORTS(nsJemallocFreeDirtyPagesRunnable, nsIRunnable)
+
+NS_IMETHODIMP
+nsJemallocFreeDirtyPagesRunnable::Run()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+#if defined(MOZ_MEMORY)
+ jemalloc_free_dirty_pages();
+#endif
+
+ return NS_OK;
+}
+
+/**
+ * The memory pressure watcher is used for listening to memory-pressure events
+ * and reacting upon them. We use one instance per process currently only for
+ * cleaning up dirty unused pages held by jemalloc.
+ */
+class nsMemoryPressureWatcher final : public nsIObserver
+{
+ ~nsMemoryPressureWatcher() {}
+
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+
+ void Init();
+
+private:
+ static bool sFreeDirtyPages;
+};
+
+NS_IMPL_ISUPPORTS(nsMemoryPressureWatcher, nsIObserver)
+
+bool nsMemoryPressureWatcher::sFreeDirtyPages = false;
+
+/**
+ * Initialize and subscribe to the memory-pressure events. We subscribe to the
+ * observer service in this method and not in the constructor because we need
+ * to hold a strong reference to 'this' before calling the observer service.
+ */
+void
+nsMemoryPressureWatcher::Init()
+{
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+
+ if (os) {
+ os->AddObserver(this, "memory-pressure", /* ownsWeak */ false);
+ }
+
+ Preferences::AddBoolVarCache(&sFreeDirtyPages, "memory.free_dirty_pages",
+ false);
+}
+
+/**
+ * Reacts to all types of memory-pressure events, launches a runnable to
+ * free dirty pages held by jemalloc.
+ */
+NS_IMETHODIMP
+nsMemoryPressureWatcher::Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aData)
+{
+ MOZ_ASSERT(!strcmp(aTopic, "memory-pressure"), "Unknown topic");
+
+ if (sFreeDirtyPages) {
+ nsCOMPtr<nsIRunnable> runnable = new nsJemallocFreeDirtyPagesRunnable();
+
+ NS_DispatchToMainThread(runnable);
+ }
+
+ return NS_OK;
+}
+
+} // namespace
+
+namespace mozilla {
+namespace AvailableMemoryTracker {
+
+void
+Activate()
+{
+#if defined(_M_IX86) && defined(XP_WIN)
+ MOZ_ASSERT(sInitialized);
+ MOZ_ASSERT(!sHooksActive);
+
+ Preferences::AddUintVarCache(&sLowVirtualMemoryThreshold,
+ "memory.low_virtual_mem_threshold_mb", 256);
+ Preferences::AddUintVarCache(&sLowPhysicalMemoryThreshold,
+ "memory.low_physical_memory_threshold_mb", 0);
+ Preferences::AddUintVarCache(&sLowCommitSpaceThreshold,
+ "memory.low_commit_space_threshold_mb", 256);
+ Preferences::AddUintVarCache(&sLowMemoryNotificationIntervalMS,
+ "memory.low_memory_notification_interval_ms",
+ 10000);
+
+ RegisterStrongMemoryReporter(new LowEventsReporter());
+ RegisterLowMemoryEventsVirtualDistinguishedAmount(
+ LowMemoryEventsVirtualDistinguishedAmount);
+ RegisterLowMemoryEventsPhysicalDistinguishedAmount(
+ LowMemoryEventsPhysicalDistinguishedAmount);
+ sHooksActive = true;
+#endif
+
+ // This object is held alive by the observer service.
+ RefPtr<nsMemoryPressureWatcher> watcher = new nsMemoryPressureWatcher();
+ watcher->Init();
+}
+
+void
+Init()
+{
+ // Do nothing on x86-64, because nsWindowsDllInterceptor is not thread-safe
+ // on 64-bit. (On 32-bit, it's probably thread-safe.) Even if we run Init()
+ // before any other of our threads are running, another process may have
+ // started a remote thread which could call VirtualAlloc!
+ //
+ // Moreover, the benefit of this code is less clear when we're a 64-bit
+ // process, because we aren't going to run out of virtual memory, and the
+ // system is likely to have a fair bit of physical memory.
+
+#if defined(_M_IX86) && defined(XP_WIN)
+ // Don't register the hooks if we're a build instrumented for PGO: If we're
+ // an instrumented build, the compiler adds function calls all over the place
+ // which may call VirtualAlloc; this makes it hard to prevent
+ // VirtualAllocHook from reentering itself.
+ if (!PR_GetEnv("MOZ_PGO_INSTRUMENTED")) {
+ sKernel32Intercept.Init("Kernel32.dll");
+ sKernel32Intercept.AddHook("VirtualAlloc",
+ reinterpret_cast<intptr_t>(VirtualAllocHook),
+ reinterpret_cast<void**>(&sVirtualAllocOrig));
+ sKernel32Intercept.AddHook("MapViewOfFile",
+ reinterpret_cast<intptr_t>(MapViewOfFileHook),
+ reinterpret_cast<void**>(&sMapViewOfFileOrig));
+
+ sGdi32Intercept.Init("Gdi32.dll");
+ sGdi32Intercept.AddHook("CreateDIBSection",
+ reinterpret_cast<intptr_t>(CreateDIBSectionHook),
+ reinterpret_cast<void**>(&sCreateDIBSectionOrig));
+ }
+
+ sInitialized = true;
+#endif
+}
+
+} // namespace AvailableMemoryTracker
+} // namespace mozilla