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
|
#include <atomic>
#include <thread>
#include <vector>
#include <c10/util/Lazy.h>
#include <gtest/gtest.h>
namespace c10_test {
// Long enough not to fit in typical SSO.
const std::string kLongString = "I am a long enough string";
TEST(LazyTest, OptimisticLazy) {
std::atomic<size_t> invocations = 0;
auto factory = [&] {
++invocations;
return kLongString;
};
c10::OptimisticLazy<std::string> s;
constexpr size_t kNumThreads = 16;
std::vector<std::thread> threads;
std::atomic<std::string*> address = nullptr;
for (size_t i = 0; i < kNumThreads; ++i) {
threads.emplace_back([&] {
auto* p = &s.ensure(factory);
auto old = address.exchange(p);
if (old != nullptr) {
// Even racing ensure()s should return a stable reference.
EXPECT_EQ(old, p);
}
});
}
for (auto& t : threads) {
t.join();
}
EXPECT_GE(invocations.load(), 1);
EXPECT_EQ(*address.load(), kLongString);
invocations = 0;
s.reset();
s.ensure(factory);
EXPECT_EQ(invocations.load(), 1);
invocations = 0;
auto sCopy = s;
EXPECT_EQ(sCopy.ensure(factory), kLongString);
EXPECT_EQ(invocations.load(), 0);
auto sMove = std::move(s);
EXPECT_EQ(sMove.ensure(factory), kLongString);
EXPECT_EQ(invocations.load(), 0);
// NOLINTNEXTLINE(bugprone-use-after-move)
EXPECT_EQ(s.ensure(factory), kLongString);
EXPECT_EQ(invocations.load(), 1);
invocations = 0;
s = sCopy;
EXPECT_EQ(s.ensure(factory), kLongString);
EXPECT_EQ(invocations.load(), 0);
s = std::move(sCopy);
EXPECT_EQ(s.ensure(factory), kLongString);
EXPECT_EQ(invocations.load(), 0);
}
TEST(LazyTest, PrecomputedLazyValue) {
static const std::string kLongString = "I am a string";
EXPECT_EQ(
std::make_shared<c10::PrecomputedLazyValue<std::string>>(kLongString)
->get(),
kLongString);
}
TEST(LazyTest, OptimisticLazyValue) {
static const std::string kLongString = "I am a string";
class LazyString : public c10::OptimisticLazyValue<std::string> {
std::string compute() const override {
return kLongString;
}
};
auto ls = std::make_shared<LazyString>();
EXPECT_EQ(ls->get(), kLongString);
// Returned reference should be stable.
EXPECT_EQ(&ls->get(), &ls->get());
}
} // namespace c10_test
|
