blob: 6ef94fcc5b91d43dcbdca0770c8649a224f63eaf (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
//
// 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:
// Asychronous tasks/threads for ANGLE, similar to a TaskRunner in Chromium.
// Can be implemented as different targets, depending on platform.
//
#ifndef LIBANGLE_WORKER_THREAD_H_
#define LIBANGLE_WORKER_THREAD_H_
#include <array>
#include <memory>
#include <vector>
#include "common/debug.h"
#include "libANGLE/features.h"
namespace angle
{
class WorkerThreadPool;
// A callback function with no return value and no arguments.
class Closure
{
public:
virtual ~Closure() = default;
virtual void operator()() = 0;
};
// An event that we can wait on, useful for joining worker threads.
class WaitableEvent : angle::NonCopyable
{
public:
WaitableEvent();
virtual ~WaitableEvent();
// Waits indefinitely for the event to be signaled.
virtual void wait() = 0;
// Peeks whether the event is ready. If ready, wait() will not block.
virtual bool isReady() = 0;
void setWorkerThreadPool(std::shared_ptr<WorkerThreadPool> pool) { mPool = pool; }
template <size_t Count>
static void WaitMany(std::array<std::shared_ptr<WaitableEvent>, Count> *waitables)
{
ASSERT(Count > 0);
for (size_t index = 0; index < Count; ++index)
{
(*waitables)[index]->wait();
}
}
private:
std::shared_ptr<WorkerThreadPool> mPool;
};
// A mock waitable event.
class WaitableEventDone final : public WaitableEvent
{
public:
void wait() override;
bool isReady() override;
};
// Request WorkerThreads from the WorkerThreadPool. Each pool can keep worker threads around so
// we avoid the costly spin up and spin down time.
class WorkerThreadPool : angle::NonCopyable
{
public:
WorkerThreadPool();
virtual ~WorkerThreadPool();
static std::shared_ptr<WorkerThreadPool> Create(bool multithreaded);
static std::shared_ptr<WaitableEvent> PostWorkerTask(std::shared_ptr<WorkerThreadPool> pool,
std::shared_ptr<Closure> task);
virtual void setMaxThreads(size_t maxThreads) = 0;
virtual bool isAsync() = 0;
private:
// Returns an event to wait on for the task to finish.
// If the pool fails to create the task, returns null.
virtual std::shared_ptr<WaitableEvent> postWorkerTask(std::shared_ptr<Closure> task) = 0;
};
} // namespace angle
#endif // LIBANGLE_WORKER_THREAD_H_
|
