summaryrefslogtreecommitdiffstats
path: root/ipc/mscom/MainThreadInvoker.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /ipc/mscom/MainThreadInvoker.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'ipc/mscom/MainThreadInvoker.cpp')
-rw-r--r--ipc/mscom/MainThreadInvoker.cpp180
1 files changed, 180 insertions, 0 deletions
diff --git a/ipc/mscom/MainThreadInvoker.cpp b/ipc/mscom/MainThreadInvoker.cpp
new file mode 100644
index 000000000..cab62a727
--- /dev/null
+++ b/ipc/mscom/MainThreadInvoker.cpp
@@ -0,0 +1,180 @@
+/* -*- 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/mscom/MainThreadInvoker.h"
+
+#include "GeckoProfiler.h"
+#include "MainThreadUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/HangMonitor.h"
+#include "mozilla/RefPtr.h"
+#include "nsServiceManagerUtils.h"
+#include "nsSystemInfo.h"
+#include "private/prpriv.h" // For PR_GetThreadID
+#include "WinUtils.h"
+
+// This gives us compiler intrinsics for the x86 PAUSE instruction
+#if defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_mm_pause)
+#define CPU_PAUSE() _mm_pause()
+#elif defined(__GNUC__) || defined(__clang__)
+#define CPU_PAUSE() __builtin_ia32_pause()
+#endif
+
+static bool sIsMulticore;
+
+namespace {
+
+/**
+ * SyncRunnable implements different code paths depending on whether or not
+ * we are running on a multiprocessor system. In the multiprocessor case, we
+ * leave the thread in a spin loop while waiting for the main thread to execute
+ * our runnable. Since spinning is pointless in the uniprocessor case, we block
+ * on an event that is set by the main thread once it has finished the runnable.
+ */
+class MOZ_RAII SyncRunnable
+{
+public:
+ explicit SyncRunnable(already_AddRefed<nsIRunnable>&& aRunnable)
+ : mDoneEvent(sIsMulticore ? nullptr :
+ ::CreateEventW(nullptr, FALSE, FALSE, nullptr))
+ , mDone(false)
+ , mRunnable(aRunnable)
+ {
+ MOZ_ASSERT(sIsMulticore || mDoneEvent);
+ MOZ_ASSERT(mRunnable);
+ }
+
+ ~SyncRunnable()
+ {
+ if (mDoneEvent) {
+ ::CloseHandle(mDoneEvent);
+ }
+ }
+
+ void Run()
+ {
+ mRunnable->Run();
+
+ if (mDoneEvent) {
+ ::SetEvent(mDoneEvent);
+ } else {
+ mDone = true;
+ }
+ }
+
+ bool WaitUntilComplete()
+ {
+ if (mDoneEvent) {
+ HANDLE handles[] = {mDoneEvent,
+ mozilla::mscom::MainThreadInvoker::GetTargetThread()};
+ DWORD waitResult = ::WaitForMultipleObjects(mozilla::ArrayLength(handles),
+ handles, FALSE, INFINITE);
+ return waitResult == WAIT_OBJECT_0;
+ }
+
+ while (!mDone) {
+ // The PAUSE instruction is a hint to the CPU that we're doing a spin
+ // loop. It is a no-op on older processors that don't support it, so
+ // it is safe to use here without any CPUID checks.
+ CPU_PAUSE();
+ }
+ return true;
+ }
+
+private:
+ HANDLE mDoneEvent;
+ mozilla::Atomic<bool> mDone;
+ nsCOMPtr<nsIRunnable> mRunnable;
+};
+
+} // anonymous namespace
+
+namespace mozilla {
+namespace mscom {
+
+HANDLE MainThreadInvoker::sMainThread = nullptr;
+
+/* static */ bool
+MainThreadInvoker::InitStatics()
+{
+ nsCOMPtr<nsIThread> mainThread;
+ nsresult rv = ::NS_GetMainThread(getter_AddRefs(mainThread));
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ PRThread* mainPrThread = nullptr;
+ rv = mainThread->GetPRThread(&mainPrThread);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ PRUint32 tid = ::PR_GetThreadID(mainPrThread);
+ sMainThread = ::OpenThread(SYNCHRONIZE | THREAD_SET_CONTEXT, FALSE, tid);
+
+ nsCOMPtr<nsIPropertyBag2> infoService = do_GetService(NS_SYSTEMINFO_CONTRACTID);
+ if (infoService) {
+ uint32_t cpuCount;
+ nsresult rv = infoService->GetPropertyAsUint32(NS_LITERAL_STRING("cpucount"),
+ &cpuCount);
+ sIsMulticore = NS_SUCCEEDED(rv) && cpuCount > 1;
+ }
+
+ return !!sMainThread;
+}
+
+MainThreadInvoker::MainThreadInvoker()
+{
+ static const bool gotStatics = InitStatics();
+ MOZ_ASSERT(gotStatics);
+}
+
+bool
+MainThreadInvoker::Invoke(already_AddRefed<nsIRunnable>&& aRunnable)
+{
+ nsCOMPtr<nsIRunnable> runnable(Move(aRunnable));
+ if (!runnable) {
+ return false;
+ }
+
+ if (NS_IsMainThread()) {
+ runnable->Run();
+ return true;
+ }
+
+ SyncRunnable syncRunnable(runnable.forget());
+
+ if (!::QueueUserAPC(&MainThreadAPC, sMainThread,
+ reinterpret_cast<UINT_PTR>(&syncRunnable))) {
+ return false;
+ }
+
+ // We should ensure a call to NtTestAlert() is made on the main thread so
+ // that the main thread will check for APCs during event processing. If we
+ // omit this then the main thread will not check its APC queue until it is
+ // idle.
+ widget::WinUtils::SetAPCPending();
+
+ return syncRunnable.WaitUntilComplete();
+}
+
+/* static */ VOID CALLBACK
+MainThreadInvoker::MainThreadAPC(ULONG_PTR aParam)
+{
+ GeckoProfilerWakeRAII wakeProfiler;
+ mozilla::HangMonitor::NotifyActivity(mozilla::HangMonitor::kGeneralActivity);
+ MOZ_ASSERT(NS_IsMainThread());
+ auto runnable = reinterpret_cast<SyncRunnable*>(aParam);
+ runnable->Run();
+}
+
+} // namespace mscom
+} // namespace mozilla