19 #ifdef FOLLY_USE_LIBSTDCPP 30 TEST(CoreCachedSharedPtr, Basic) {
31 auto p = std::make_shared<int>(1);
32 std::weak_ptr<int> wp(p);
37 std::shared_ptr<int> p2 = cached.get();
38 std::weak_ptr<int> wp2 = wcached.get();
57 template <
class Operation>
58 void parallelRun(Operation
op,
size_t numThreads,
size_t iters) {
59 std::vector<std::thread>
threads;
64 for (
size_t t = 0;
t < numThreads; ++
t) {
65 threads.emplace_back([&] {
66 for (
size_t i = 0;
i < iters; ++
i) {
72 for (
auto&
t : threads) {
77 void benchmarkSharedPtrCopy(
size_t numThreads,
size_t iters) {
78 auto p = std::make_shared<int>(1);
79 parallelRun([&] {
return p; }, numThreads, iters);
82 void benchmarkWeakPtrLock(
size_t numThreads,
size_t iters) {
83 auto p = std::make_shared<int>(1);
84 std::weak_ptr<int> wp = p;
85 parallelRun([&] {
return wp.lock(); }, numThreads, iters);
88 void benchmarkAtomicSharedPtrCopy(
size_t numThreads,
size_t iters) {
89 auto s = std::make_shared<int>(1);
92 parallelRun([&] {
return p.load(); }, numThreads, iters);
95 void benchmarkCoreCachedSharedPtrGet(
size_t numThreads,
size_t iters) {
97 parallelRun([&] {
return p.get(); }, numThreads, iters);
100 void benchmarkCoreCachedWeakPtrLock(
size_t numThreads,
size_t iters) {
103 parallelRun([&] {
return wp.get().lock(); }, numThreads, iters);
106 void benchmarkAtomicCoreCachedSharedPtrGet(
size_t numThreads,
size_t iters) {
108 parallelRun([&] {
return p.get(); }, numThreads, iters);
114 benchmarkSharedPtrCopy(1, n);
117 benchmarkWeakPtrLock(1, n);
119 BENCHMARK(AtomicSharedPtrSingleThread, n) {
120 benchmarkAtomicSharedPtrCopy(1, n);
122 BENCHMARK(CoreCachedSharedPtrSingleThread, n) {
123 benchmarkCoreCachedSharedPtrGet(1, n);
125 BENCHMARK(CoreCachedWeakPtrSingleThread, n) {
126 benchmarkCoreCachedWeakPtrLock(1, n);
128 BENCHMARK(AtomicCoreCachedSharedPtrSingleThread, n) {
129 benchmarkAtomicCoreCachedSharedPtrGet(1, n);
135 benchmarkSharedPtrCopy(4, n);
138 benchmarkWeakPtrLock(4, n);
141 benchmarkAtomicSharedPtrCopy(4, n);
143 BENCHMARK(CoreCachedSharedPtr4Threads, n) {
144 benchmarkCoreCachedSharedPtrGet(4, n);
146 BENCHMARK(CoreCachedWeakPtr4Threads, n) {
147 benchmarkCoreCachedWeakPtrLock(4, n);
149 BENCHMARK(AtomicCoreCachedSharedPtr4Threads, n) {
150 benchmarkAtomicCoreCachedSharedPtrGet(4, n);
156 benchmarkSharedPtrCopy(16, n);
159 benchmarkWeakPtrLock(16, n);
162 benchmarkAtomicSharedPtrCopy(16, n);
164 BENCHMARK(CoreCachedSharedPtr16Threads, n) {
165 benchmarkCoreCachedSharedPtrGet(16, n);
167 BENCHMARK(CoreCachedWeakPtr16Threads, n) {
168 benchmarkCoreCachedWeakPtrLock(16, n);
170 BENCHMARK(AtomicCoreCachedSharedPtr16Threads, n) {
171 benchmarkAtomicCoreCachedSharedPtrGet(16, n);
176 BENCHMARK(SharedPtrSingleThreadReset, n) {
177 auto p = std::make_shared<int>(1);
178 parallelRun([&] { p = std::make_shared<int>(1); }, 1, n);
180 BENCHMARK(AtomicSharedPtrSingleThreadReset, n) {
181 auto s = std::make_shared<int>(1);
184 parallelRun([&] { p.store(std::make_shared<int>(1)); }, 1, n);
186 BENCHMARK(CoreCachedSharedPtrSingleThreadReset, n) {
188 parallelRun([&] { p.reset(std::make_shared<int>(1)); }, 1, n);
190 BENCHMARK(AtomicCoreCachedSharedPtrSingleThreadReset, n) {
192 parallelRun([&] { p.reset(std::make_shared<int>(1)); }, 1, n);
197 gflags::ParseCommandLineFlags(&argc, &argv,
true);
200 if (ret == 0 && FLAGS_benchmark) {
207 #endif // #ifdef FOLLY_USE_LIBSTDCPP #define TEST(test_case_name, test_name)
#define ASSERT_EQ(val1, val2)
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_
std::vector< std::thread::id > threads
#define BENCHMARK(name,...)
void store(SharedPtr n, std::memory_order order=std::memory_order_seq_cst)
GTEST_API_ void InitGoogleTest(int *argc, char **argv)
#define ASSERT_FALSE(condition)
#define ASSERT_TRUE(condition)
#define BENCHMARK_DRAW_LINE()