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
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkOnce_DEFINED
#define SkOnce_DEFINED
#include <atomic>
#include <utility>
#include "SkTypes.h"
// SkOnce provides call-once guarantees for Skia, much like std::once_flag/std::call_once().
//
// There should be no particularly error-prone gotcha use cases when using SkOnce.
// It works correctly as a class member, a local, a global, a function-scoped static, whatever.
class SkOnce {
public:
template <typename Fn, typename... Args>
void operator()(Fn&& fn, Args&&... args) {
auto state = fState.load(std::memory_order_acquire);
if (state == Done) {
return;
}
if (state == NotStarted) {
// Try to claim the job of calling fn() by swapping from NotStarted to Calling.
// See [1] below for why we use std::memory_order_acquire instead of relaxed.
if (fState.compare_exchange_strong(state, Calling, std::memory_order_acquire)) {
// Claimed! Call fn(), then mark this SkOnce as Done.
fn(std::forward<Args>(args)...);
return fState.store(Done, std::memory_order_release);
}
}
while (state == Calling) {
// Some other thread is calling fn(). Wait for them to finish.
state = fState.load(std::memory_order_acquire);
}
SkASSERT(state == Done);
}
private:
enum State : uint8_t { NotStarted, Calling, Done};
std::atomic<uint8_t> fState{NotStarted};
};
/* [1] Why do we compare_exchange_strong() with std::memory_order_acquire instead of relaxed?
*
* If we succeed, we really only need a relaxed compare_exchange_strong()... we're the ones
* who are about to do a release store, so there's certainly nothing yet for an acquire to
* synchronize with.
*
* If that compare_exchange_strong() fails, we're either in Calling or Done state.
* Again, if we're in Calling state, relaxed would have been fine: the spin loop will
* acquire up to the Calling thread's release store.
*
* But if that compare_exchange_strong() fails and we find ourselves in the Done state,
* we've never done an acquire load to sync up to the store of that Done state.
*
* So on failure we need an acquire load. Generally the failure memory order cannot be
* stronger than the success memory order, so we need acquire on success too. The single
* memory order version of compare_exchange_strong() uses the same acquire order for both.
*/
#endif // SkOnce_DEFINED
|
