diff options
author | Tobias Hunger <tobias.hunger@qt.io> | 2019-04-16 16:32:08 +0200 |
---|---|---|
committer | Tobias Hunger <tobias.hunger@qt.io> | 2019-04-16 16:32:08 +0200 |
commit | 6630937e63ae5797487b86743a7733c8ae5cc42c (patch) | |
tree | 3d53dacf6430f9099e1fb20835881205de674961 /src/3rdparty/angle/src/libANGLE/WorkerThread.cpp | |
parent | 37ed6dae00640f9cc980ffda05347c12a7eb5d7e (diff) | |
parent | c7af193d2e49e9f10b86262e63d8d13abf72b5cf (diff) |
Merge commit 'dev' into 'wip/cmake-merge'
Change-Id: I176c40d031be26a1dd1cf08843e448a660598783
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/WorkerThread.cpp')
-rw-r--r-- | src/3rdparty/angle/src/libANGLE/WorkerThread.cpp | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/WorkerThread.cpp b/src/3rdparty/angle/src/libANGLE/WorkerThread.cpp new file mode 100644 index 0000000000..b5d789ef93 --- /dev/null +++ b/src/3rdparty/angle/src/libANGLE/WorkerThread.cpp @@ -0,0 +1,157 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// WorkerThread: +// Task running thread for ANGLE, similar to a TaskRunner in Chromium. +// Might be implemented differently depending on platform. +// + +#include "libANGLE/WorkerThread.h" + +namespace angle +{ + +namespace priv +{ +// SingleThreadedWorkerPool implementation. +SingleThreadedWorkerPool::SingleThreadedWorkerPool(size_t maxThreads) + : WorkerThreadPoolBase(maxThreads) +{ +} + +SingleThreadedWorkerPool::~SingleThreadedWorkerPool() +{ +} + +SingleThreadedWaitableEvent SingleThreadedWorkerPool::postWorkerTaskImpl(Closure *task) +{ + (*task)(); + return SingleThreadedWaitableEvent(EventResetPolicy::Automatic, EventInitialState::Signaled); +} + +// SingleThreadedWaitableEvent implementation. +SingleThreadedWaitableEvent::SingleThreadedWaitableEvent() + : SingleThreadedWaitableEvent(EventResetPolicy::Automatic, EventInitialState::NonSignaled) +{ +} + +SingleThreadedWaitableEvent::SingleThreadedWaitableEvent(EventResetPolicy resetPolicy, + EventInitialState initialState) + : WaitableEventBase(resetPolicy, initialState) +{ +} + +SingleThreadedWaitableEvent::~SingleThreadedWaitableEvent() +{ +} + +SingleThreadedWaitableEvent::SingleThreadedWaitableEvent(SingleThreadedWaitableEvent &&other) + : WaitableEventBase(std::move(other)) +{ +} + +SingleThreadedWaitableEvent &SingleThreadedWaitableEvent::operator=( + SingleThreadedWaitableEvent &&other) +{ + return copyBase(std::move(other)); +} + +void SingleThreadedWaitableEvent::resetImpl() +{ + mSignaled = false; +} + +void SingleThreadedWaitableEvent::waitImpl() +{ +} + +void SingleThreadedWaitableEvent::signalImpl() +{ + mSignaled = true; +} + +#if (ANGLE_STD_ASYNC_WORKERS == ANGLE_ENABLED) +// AsyncWorkerPool implementation. +AsyncWorkerPool::AsyncWorkerPool(size_t maxThreads) : WorkerThreadPoolBase(maxThreads) +{ +} + +AsyncWorkerPool::~AsyncWorkerPool() +{ +} + +AsyncWaitableEvent AsyncWorkerPool::postWorkerTaskImpl(Closure *task) +{ + auto future = std::async(std::launch::async, [task] { (*task)(); }); + + AsyncWaitableEvent waitable(EventResetPolicy::Automatic, EventInitialState::NonSignaled); + + waitable.setFuture(std::move(future)); + + return waitable; +} + +// AsyncWaitableEvent implementation. +AsyncWaitableEvent::AsyncWaitableEvent() + : AsyncWaitableEvent(EventResetPolicy::Automatic, EventInitialState::NonSignaled) +{ +} + +AsyncWaitableEvent::AsyncWaitableEvent(EventResetPolicy resetPolicy, EventInitialState initialState) + : WaitableEventBase(resetPolicy, initialState) +{ +} + +AsyncWaitableEvent::~AsyncWaitableEvent() +{ +} + +AsyncWaitableEvent::AsyncWaitableEvent(AsyncWaitableEvent &&other) + : WaitableEventBase(std::move(other)), mFuture(std::move(other.mFuture)) +{ +} + +AsyncWaitableEvent &AsyncWaitableEvent::operator=(AsyncWaitableEvent &&other) +{ + std::swap(mFuture, other.mFuture); + return copyBase(std::move(other)); +} + +void AsyncWaitableEvent::setFuture(std::future<void> &&future) +{ + mFuture = std::move(future); +} + +void AsyncWaitableEvent::resetImpl() +{ + mSignaled = false; + mFuture = std::future<void>(); +} + +void AsyncWaitableEvent::waitImpl() +{ + if (mSignaled || !mFuture.valid()) + { + return; + } + + mFuture.wait(); + signal(); +} + +void AsyncWaitableEvent::signalImpl() +{ + mSignaled = true; + + if (mResetPolicy == EventResetPolicy::Automatic) + { + reset(); + } +} +#endif // (ANGLE_STD_ASYNC_WORKERS == ANGLE_ENABLED) + +} // namespace priv + +} // namespace angle |