mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 05:35:31 +00:00
334f89c567
The new names make it clearer that these actions apply to just one thread. - profiler_sleep_start() --> profiler_thread_sleep() - profiler_sleep_end() --> profiler_thread_wake() - profiler_is_sleeping() --> profiler_thread_is_sleeping() - GeckoProfilerSleepRAII --> GeckoProfilerThreadSleepRAII - GeckoProfilerWakeRAII --> GeckoProfilerThreadWakeRAII
181 lines
4.8 KiB
C++
181 lines
4.8 KiB
C++
/* -*- 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)
|
|
{
|
|
GeckoProfilerThreadWakeRAII wake;
|
|
mozilla::HangMonitor::NotifyActivity(mozilla::HangMonitor::kGeneralActivity);
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
auto runnable = reinterpret_cast<SyncRunnable*>(aParam);
|
|
runnable->Run();
|
|
}
|
|
|
|
} // namespace mscom
|
|
} // namespace mozilla
|