Add m-esr52 at 52.6.0

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