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
|
// Copyright 2012 the V8 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.
// emulates google3/base/once.h
//
// This header is intended to be included only by v8's internal code. Users
// should not use this directly.
//
// This is basically a portable version of pthread_once().
//
// This header declares:
// * A type called OnceType.
// * A macro V8_DECLARE_ONCE() which declares a (global) variable of type
// OnceType.
// * A function CallOnce(OnceType* once, void (*init_func)()).
// This function, when invoked multiple times given the same OnceType object,
// will invoke init_func on the first call only, and will make sure none of
// the calls return before that first call to init_func has finished.
//
// Additionally, the following features are supported:
// * A macro V8_ONCE_INIT which is expanded into the expression used to
// initialize a OnceType. This is only useful when clients embed a OnceType
// into a structure of their own and want to initialize it statically.
// * The user can provide a parameter which CallOnce() forwards to the
// user-provided function when it is called. Usage example:
// CallOnce(&my_once, &MyFunctionExpectingIntArgument, 10);
// * This implementation guarantees that OnceType is a POD (i.e. no static
// initializer generated).
//
// This implements a way to perform lazy initialization. It's more efficient
// than using mutexes as no lock is needed if initialization has already
// happened.
//
// Example usage:
// void Init();
// V8_DECLARE_ONCE(once_init);
//
// // Calls Init() exactly once.
// void InitOnce() {
// CallOnce(&once_init, &Init);
// }
//
// Note that if CallOnce() is called before main() has begun, it must
// only be called by the thread that will eventually call main() -- that is,
// the thread that performs dynamic initialization. In general this is a safe
// assumption since people don't usually construct threads before main() starts,
// but it is technically not guaranteed. Unfortunately, Win32 provides no way
// whatsoever to statically-initialize its synchronization primitives, so our
// only choice is to assume that dynamic initialization is single-threaded.
#ifndef V8_BASE_ONCE_H_
#define V8_BASE_ONCE_H_
#include <stddef.h>
#include <atomic>
#include <functional>
#include "src/base/base-export.h"
namespace v8 {
namespace base {
using OnceType = std::atomic<uint8_t>;
#define V8_ONCE_INIT \
{ 0 }
#define V8_DECLARE_ONCE(NAME) ::v8::base::OnceType NAME
enum : uint8_t {
ONCE_STATE_UNINITIALIZED = 0,
ONCE_STATE_EXECUTING_FUNCTION = 1,
ONCE_STATE_DONE = 2
};
using PointerArgFunction = void (*)(void* arg);
template <typename T>
struct OneArgFunction {
using type = void (*)(T);
};
V8_BASE_EXPORT void CallOnceImpl(OnceType* once,
std::function<void()> init_func);
inline void CallOnce(OnceType* once, std::function<void()> init_func) {
if (once->load(std::memory_order_acquire) != ONCE_STATE_DONE) {
CallOnceImpl(once, init_func);
}
}
template <typename Arg>
inline void CallOnce(OnceType* once,
typename OneArgFunction<Arg*>::type init_func, Arg* arg) {
if (once->load(std::memory_order_acquire) != ONCE_STATE_DONE) {
CallOnceImpl(once, [=]() { init_func(arg); });
}
}
} // namespace base
} // namespace v8
#endif // V8_BASE_ONCE_H_
|
