blob: eb0412a55ee485902d3b4814f88cecbc5c2e80a4 (
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkExecutor.h"
#include "SkMakeUnique.h"
#include "SkMutex.h"
#include "SkSemaphore.h"
#include "SkSpinlock.h"
#include "SkTArray.h"
#include <deque>
#include <thread>
#if defined(SK_BUILD_FOR_WIN32)
#include <windows.h>
static int num_cores() {
SYSTEM_INFO sysinfo;
GetNativeSystemInfo(&sysinfo);
return (int)sysinfo.dwNumberOfProcessors;
}
#else
#include <unistd.h>
static int num_cores() {
return (int)sysconf(_SC_NPROCESSORS_ONLN);
}
#endif
SkExecutor::~SkExecutor() {}
// The default default SkExecutor is an SkTrivialExecutor, which just runs the work right away.
class SkTrivialExecutor final : public SkExecutor {
void add(std::function<void(void)> work) override {
work();
}
};
static SkTrivialExecutor gTrivial;
static SkExecutor* gDefaultExecutor = &gTrivial;
SkExecutor& SkExecutor::GetDefault() {
return *gDefaultExecutor;
}
void SkExecutor::SetDefault(SkExecutor* executor) {
gDefaultExecutor = executor ? executor : &gTrivial;
}
// We'll always push_back() new work, but pop from the front of deques or the back of SkTArray.
static inline std::function<void(void)> pop(std::deque<std::function<void(void)>>* list) {
std::function<void(void)> fn = std::move(list->front());
list->pop_front();
return fn;
}
static inline std::function<void(void)> pop(SkTArray<std::function<void(void)>>* list) {
std::function<void(void)> fn = std::move(list->back());
list->pop_back();
return fn;
}
// An SkThreadPool is an executor that runs work on a fixed pool of OS threads.
template <typename WorkList>
class SkThreadPool final : public SkExecutor {
public:
explicit SkThreadPool(int threads) {
for (int i = 0; i < threads; i++) {
fThreads.emplace_back(&Loop, this);
}
}
~SkThreadPool() override {
// Signal each thread that it's time to shut down.
for (int i = 0; i < fThreads.count(); i++) {
this->add(nullptr);
}
// Wait for each thread to shut down.
for (int i = 0; i < fThreads.count(); i++) {
fThreads[i].join();
}
}
virtual void add(std::function<void(void)> work) override {
// Add some work to our pile of work to do.
{
SkAutoExclusive lock(fWorkLock);
fWork.emplace_back(std::move(work));
}
// Tell the Loop() threads to pick it up.
fWorkAvailable.signal(1);
}
virtual void borrow() override {
// If there is work waiting, do it.
if (fWorkAvailable.try_wait()) {
SkAssertResult(this->do_work());
}
}
private:
// This method should be called only when fWorkAvailable indicates there's work to do.
bool do_work() {
std::function<void(void)> work;
{
SkAutoExclusive lock(fWorkLock);
SkASSERT(!fWork.empty()); // TODO: if (fWork.empty()) { return true; } ?
work = pop(&fWork);
}
if (!work) {
return false; // This is Loop()'s signal to shut down.
}
work();
return true;
}
static void Loop(void* ctx) {
auto pool = (SkThreadPool*)ctx;
do {
pool->fWorkAvailable.wait();
} while (pool->do_work());
}
// Both SkMutex and SkSpinlock can work here.
using Lock = SkMutex;
SkTArray<std::thread> fThreads;
WorkList fWork;
Lock fWorkLock;
SkSemaphore fWorkAvailable;
};
std::unique_ptr<SkExecutor> SkExecutor::MakeFIFOThreadPool(int threads) {
using WorkList = std::deque<std::function<void(void)>>;
return skstd::make_unique<SkThreadPool<WorkList>>(threads > 0 ? threads : num_cores());
}
std::unique_ptr<SkExecutor> SkExecutor::MakeLIFOThreadPool(int threads) {
using WorkList = SkTArray<std::function<void(void)>>;
return skstd::make_unique<SkThreadPool<WorkList>>(threads > 0 ? threads : num_cores());
}
|
