folly/experimental/test/SingletonTest.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <thread>
  18
  19 #include <folly/experimental/Singleton.h>
  20
  21 #include <folly/Benchmark.h>
  22
  23 #include <glog/logging.h>
  24 #include <gtest/gtest.h>
  25
  26 using namespace folly;
  27
  28 // A simple class that tracks how often instances of the class and
  29 // subclasses are created, and the ordering.  Also tracks a global
  30 // unique counter for each object.
  31 std::atomic<size_t> global_counter(19770326);
  32 struct Watchdog {
  33   static std::vector<Watchdog*> creation_order;
  34   Watchdog() : serial_number(++global_counter) {
  35     creation_order.push_back(this);
  36   }
  37
  38   ~Watchdog() {
  39     if (creation_order.back() != this) {
  40       throw std::out_of_range("Watchdog destruction order mismatch");
  41     }
  42     creation_order.pop_back();
  43   }
  44
  45   const size_t serial_number;
  46   size_t livingWatchdogCount() const { return creation_order.size(); }
  47
  48   Watchdog(const Watchdog&) = delete;
  49   Watchdog& operator=(const Watchdog&) = delete;
  50   Watchdog(Watchdog&&) noexcept = default;
  51 };
  52
  53 std::vector<Watchdog*> Watchdog::creation_order;
  54
  55 // Some basic types we use for tracking.
  56 struct ChildWatchdog : public Watchdog {};
  57 struct GlobalWatchdog : public Watchdog {};
  58 struct UnregisteredWatchdog : public Watchdog {};
  59
  60 namespace {
  61 Singleton<GlobalWatchdog> global_watchdog;
  62 }
  63
  64 // Test basic global usage (the default way singletons will generally
  65 // be used).
  66 TEST(Singleton, BasicGlobalUsage) {
  67   EXPECT_EQ(Watchdog::creation_order.size(), 0);
  68   EXPECT_EQ(SingletonVault::singleton()->registeredSingletonCount(), 1);
  69   EXPECT_EQ(SingletonVault::singleton()->livingSingletonCount(), 0);
  70   auto wd1 = Singleton<GlobalWatchdog>::get();
  71   EXPECT_NE(wd1, nullptr);
  72   EXPECT_EQ(Watchdog::creation_order.size(), 1);
  73   auto wd2 = Singleton<GlobalWatchdog>::get();
  74   EXPECT_NE(wd2, nullptr);
  75   EXPECT_EQ(wd1, wd2);
  76   EXPECT_EQ(Watchdog::creation_order.size(), 1);
  77   SingletonVault::singleton()->destroyInstances();
  78   EXPECT_EQ(Watchdog::creation_order.size(), 0);
  79 }
  80
  81 TEST(Singleton, MissingSingleton) {
  82   EXPECT_THROW([]() { auto u = Singleton<UnregisteredWatchdog>::get(); }(),
  83                std::out_of_range);
  84 }
  85
  86 struct BasicUsageTag {};
  87 template <typename T, typename Tag = detail::DefaultTag>
  88 using SingletonBasicUsage = Singleton <T, Tag, BasicUsageTag>;
  89
  90 // Exercise some basic codepaths ensuring registration order and
  91 // destruction order happen as expected, that instances are created
  92 // when expected, etc etc.
  93 TEST(Singleton, BasicUsage) {
  94   auto& vault = *SingletonVault::singleton<BasicUsageTag>();
  95
  96   EXPECT_EQ(vault.registeredSingletonCount(), 0);
  97   SingletonBasicUsage<Watchdog> watchdog_singleton;
  98   EXPECT_EQ(vault.registeredSingletonCount(), 1);
  99
 100   SingletonBasicUsage<ChildWatchdog> child_watchdog_singleton;
 101   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 102
 103   vault.registrationComplete();
 104
 105   Watchdog* s1 = SingletonBasicUsage<Watchdog>::get();
 106   EXPECT_NE(s1, nullptr);
 107
 108   Watchdog* s2 = SingletonBasicUsage<Watchdog>::get();
 109   EXPECT_NE(s2, nullptr);
 110
 111   EXPECT_EQ(s1, s2);
 112
 113   auto s3 = SingletonBasicUsage<ChildWatchdog>::get();
 114   EXPECT_NE(s3, nullptr);
 115   EXPECT_NE(s2, s3);
 116
 117   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 118   EXPECT_EQ(vault.livingSingletonCount(), 2);
 119
 120   vault.destroyInstances();
 121   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 122   EXPECT_EQ(vault.livingSingletonCount(), 0);
 123 }
 124
 125 struct DirectUsageTag {};
 126 template <typename T, typename Tag = detail::DefaultTag>
 127 using SingletonDirectUsage = Singleton <T, Tag, DirectUsageTag>;
 128
 129 TEST(Singleton, DirectUsage) {
 130   auto& vault = *SingletonVault::singleton<DirectUsageTag>();
 131
 132   EXPECT_EQ(vault.registeredSingletonCount(), 0);
 133
 134   // Verify we can get to the underlying singletons via directly using
 135   // the singleton definition.
 136   SingletonDirectUsage<Watchdog> watchdog;
 137   struct TestTag {};
 138   SingletonDirectUsage<Watchdog, TestTag> named_watchdog;
 139   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 140   vault.registrationComplete();
 141
 142   EXPECT_NE(watchdog.ptr(), nullptr);
 143   EXPECT_EQ(watchdog.ptr(), SingletonDirectUsage<Watchdog>::get());
 144   EXPECT_NE(watchdog.ptr(), named_watchdog.ptr());
 145   EXPECT_EQ(watchdog->livingWatchdogCount(), 2);
 146   EXPECT_EQ((*watchdog).livingWatchdogCount(), 2);
 147
 148   vault.destroyInstances();
 149 }
 150
 151 struct NamedUsageTag {};
 152 template <typename T, typename Tag = detail::DefaultTag>
 153 using SingletonNamedUsage = Singleton <T, Tag, NamedUsageTag>;
 154
 155 TEST(Singleton, NamedUsage) {
 156   auto& vault = *SingletonVault::singleton<NamedUsageTag>();
 157
 158   EXPECT_EQ(vault.registeredSingletonCount(), 0);
 159
 160   // Define two named Watchdog singletons and one unnamed singleton.
 161   struct Watchdog1 {};
 162   struct Watchdog2 {};
 163   typedef detail::DefaultTag Watchdog3;
 164   SingletonNamedUsage<Watchdog, Watchdog1> watchdog1_singleton;
 165   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 166   SingletonNamedUsage<Watchdog, Watchdog2> watchdog2_singleton;
 167   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 168   SingletonNamedUsage<Watchdog, Watchdog3> watchdog3_singleton;
 169   EXPECT_EQ(vault.registeredSingletonCount(), 3);
 170
 171   vault.registrationComplete();
 172
 173   // Verify our three singletons are distinct and non-nullptr.
 174   Watchdog* s1 = SingletonNamedUsage<Watchdog, Watchdog1>::get();
 175   EXPECT_EQ(s1, watchdog1_singleton.ptr());
 176   Watchdog* s2 = SingletonNamedUsage<Watchdog, Watchdog2>::get();
 177   EXPECT_EQ(s2, watchdog2_singleton.ptr());
 178   EXPECT_NE(s1, s2);
 179   Watchdog* s3 = SingletonNamedUsage<Watchdog, Watchdog3>::get();
 180   EXPECT_EQ(s3, watchdog3_singleton.ptr());
 181   EXPECT_NE(s3, s1);
 182   EXPECT_NE(s3, s2);
 183
 184   // Verify the "default" singleton is the same as the DefaultTag-tagged
 185   // singleton.
 186   Watchdog* s4 = SingletonNamedUsage<Watchdog>::get();
 187   EXPECT_EQ(s4, watchdog3_singleton.ptr());
 188
 189   vault.destroyInstances();
 190 }
 191
 192 struct NaughtyUsageTag {};
 193 template <typename T, typename Tag = detail::DefaultTag>
 194 using SingletonNaughtyUsage = Singleton <T, Tag, NaughtyUsageTag>;
 195 struct NaughtyUsageTag2 {};
 196 template <typename T, typename Tag = detail::DefaultTag>
 197 using SingletonNaughtyUsage2 = Singleton <T, Tag, NaughtyUsageTag2>;
 198
 199 // Some pathological cases such as getting unregistered singletons,
 200 // double registration, etc.
 201 TEST(Singleton, NaughtyUsage) {
 202   auto& vault = *SingletonVault::singleton<NaughtyUsageTag>();
 203
 204   vault.registrationComplete();
 205
 206   // Unregistered.
 207   EXPECT_THROW(Singleton<Watchdog>::get(), std::out_of_range);
 208   EXPECT_THROW(SingletonNaughtyUsage<Watchdog>::get(), std::out_of_range);
 209
 210   vault.destroyInstances();
 211
 212   auto& vault2 = *SingletonVault::singleton<NaughtyUsageTag2>();
 213
 214   EXPECT_THROW(SingletonNaughtyUsage2<Watchdog>::get(), std::logic_error);
 215   SingletonNaughtyUsage2<Watchdog> watchdog_singleton;
 216   // double registration
 217   EXPECT_THROW([]() {
 218       SingletonNaughtyUsage2<Watchdog> watchdog_singleton;
 219     }(),
 220     std::logic_error);
 221   vault2.destroyInstances();
 222   // double registration after destroy
 223   EXPECT_THROW([]() {
 224       SingletonNaughtyUsage2<Watchdog> watchdog_singleton;
 225     }(),
 226     std::logic_error);
 227 }
 228
 229 struct SharedPtrUsageTag {};
 230 template <typename T, typename Tag = detail::DefaultTag>
 231 using SingletonSharedPtrUsage = Singleton <T, Tag, SharedPtrUsageTag>;
 232
 233 TEST(Singleton, SharedPtrUsage) {
 234   auto& vault = *SingletonVault::singleton<SharedPtrUsageTag>();
 235
 236   EXPECT_EQ(vault.registeredSingletonCount(), 0);
 237   SingletonSharedPtrUsage<Watchdog> watchdog_singleton;
 238   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 239
 240   SingletonSharedPtrUsage<ChildWatchdog> child_watchdog_singleton;
 241   EXPECT_EQ(vault.registeredSingletonCount(), 2);
 242
 243   struct ATag {};
 244   SingletonSharedPtrUsage<Watchdog, ATag> named_watchdog_singleton;
 245   vault.registrationComplete();
 246
 247   Watchdog* s1 = SingletonSharedPtrUsage<Watchdog>::get();
 248   EXPECT_NE(s1, nullptr);
 249
 250   Watchdog* s2 = SingletonSharedPtrUsage<Watchdog>::get();
 251   EXPECT_NE(s2, nullptr);
 252
 253   EXPECT_EQ(s1, s2);
 254
 255   auto weak_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
 256   auto shared_s1 = weak_s1.lock();
 257   EXPECT_EQ(shared_s1.get(), s1);
 258   EXPECT_EQ(shared_s1.use_count(), 2);
 259
 260   {
 261     auto named_weak_s1 =
 262       SingletonSharedPtrUsage<Watchdog, ATag>::get_weak();
 263     auto locked = named_weak_s1.lock();
 264     EXPECT_NE(locked.get(), shared_s1.get());
 265   }
 266
 267   LOG(ERROR) << "The following log message regarding shared_ptr is expected";
 268   {
 269     auto start_time = std::chrono::steady_clock::now();
 270     vault.destroyInstances();
 271     auto duration = std::chrono::steady_clock::now() - start_time;
 272     EXPECT_TRUE(duration > std::chrono::seconds{4} &&
 273                 duration < std::chrono::seconds{6});
 274   }
 275   EXPECT_EQ(vault.registeredSingletonCount(), 3);
 276   EXPECT_EQ(vault.livingSingletonCount(), 0);
 277
 278   EXPECT_EQ(shared_s1.use_count(), 1);
 279   EXPECT_EQ(shared_s1.get(), s1);
 280
 281   auto locked_s1 = weak_s1.lock();
 282   EXPECT_EQ(locked_s1.get(), s1);
 283   EXPECT_EQ(shared_s1.use_count(), 2);
 284   LOG(ERROR) << "The following log message with stack trace is expected";
 285   locked_s1.reset();
 286   EXPECT_EQ(shared_s1.use_count(), 1);
 287
 288   // Track serial number rather than pointer since the memory could be
 289   // re-used when we create new_s1.
 290   auto old_serial = shared_s1->serial_number;
 291   shared_s1.reset();
 292   locked_s1 = weak_s1.lock();
 293   EXPECT_TRUE(weak_s1.expired());
 294
 295   auto empty_s1 = SingletonSharedPtrUsage<Watchdog>::get_weak();
 296   EXPECT_FALSE(empty_s1.lock());
 297
 298   vault.reenableInstances();
 299
 300   // Singleton should be re-created only after reenableInstances() was called.
 301   Watchdog* new_s1 = SingletonSharedPtrUsage<Watchdog>::get();
 302   EXPECT_NE(new_s1->serial_number, old_serial);
 303
 304   auto new_s1_weak = SingletonSharedPtrUsage<Watchdog>::get_weak();
 305   auto new_s1_shared = new_s1_weak.lock();
 306   std::thread t([new_s1_shared]() mutable {
 307       std::this_thread::sleep_for(std::chrono::seconds{2});
 308       new_s1_shared.reset();
 309     });
 310   new_s1_shared.reset();
 311   {
 312     auto start_time = std::chrono::steady_clock::now();
 313     vault.destroyInstances();
 314     auto duration = std::chrono::steady_clock::now() - start_time;
 315     EXPECT_TRUE(duration > std::chrono::seconds{1} &&
 316                 duration < std::chrono::seconds{3});
 317   }
 318   EXPECT_TRUE(new_s1_weak.expired());
 319   t.join();
 320 }
 321
 322 // Some classes to test singleton dependencies.  NeedySingleton has a
 323 // dependency on NeededSingleton, which happens during its
 324 // construction.
 325 struct NeedyTag {};
 326 template <typename T, typename Tag = detail::DefaultTag>
 327 using SingletonNeedy = Singleton <T, Tag, NeedyTag>;
 328
 329 struct NeededSingleton {};
 330 struct NeedySingleton {
 331   NeedySingleton() {
 332     auto unused = SingletonNeedy<NeededSingleton>::get();
 333     EXPECT_NE(unused, nullptr);
 334   }
 335 };
 336
 337 // Ensure circular dependencies fail -- a singleton that needs itself, whoops.
 338 struct SelfNeedyTag {};
 339 template <typename T, typename Tag = detail::DefaultTag>
 340 using SingletonSelfNeedy = Singleton <T, Tag, SelfNeedyTag>;
 341
 342 struct SelfNeedySingleton {
 343   SelfNeedySingleton() {
 344     auto unused = SingletonSelfNeedy<SelfNeedySingleton>::get();
 345     EXPECT_NE(unused, nullptr);
 346   }
 347 };
 348
 349 TEST(Singleton, SingletonDependencies) {
 350   SingletonNeedy<NeededSingleton> needed_singleton;
 351   SingletonNeedy<NeedySingleton> needy_singleton;
 352   auto& needy_vault = *SingletonVault::singleton<NeedyTag>();
 353
 354   needy_vault.registrationComplete();
 355
 356   EXPECT_EQ(needy_vault.registeredSingletonCount(), 2);
 357   EXPECT_EQ(needy_vault.livingSingletonCount(), 0);
 358
 359   auto needy = SingletonNeedy<NeedySingleton>::get();
 360   EXPECT_EQ(needy_vault.livingSingletonCount(), 2);
 361
 362   SingletonSelfNeedy<SelfNeedySingleton> self_needy_singleton;
 363   auto& self_needy_vault = *SingletonVault::singleton<SelfNeedyTag>();
 364
 365   self_needy_vault.registrationComplete();
 366   EXPECT_THROW([]() {
 367       SingletonSelfNeedy<SelfNeedySingleton>::get();
 368     }(),
 369     std::out_of_range);
 370 }
 371
 372 // A test to ensure multiple threads contending on singleton creation
 373 // properly wait for creation rather than thinking it is a circular
 374 // dependency.
 375 class Slowpoke : public Watchdog {
 376  public:
 377   Slowpoke() { std::this_thread::sleep_for(std::chrono::milliseconds(10)); }
 378 };
 379
 380 struct ConcurrencyTag {};
 381 template <typename T, typename Tag = detail::DefaultTag>
 382 using SingletonConcurrency = Singleton <T, Tag, ConcurrencyTag>;
 383
 384 TEST(Singleton, SingletonConcurrency) {
 385   auto& vault = *SingletonVault::singleton<ConcurrencyTag>();
 386   SingletonConcurrency<Slowpoke> slowpoke_singleton;
 387   vault.registrationComplete();
 388
 389   std::mutex gatekeeper;
 390   gatekeeper.lock();
 391   auto func = [&gatekeeper]() {
 392     gatekeeper.lock();
 393     gatekeeper.unlock();
 394     auto unused = SingletonConcurrency<Slowpoke>::get();
 395   };
 396
 397   EXPECT_EQ(vault.livingSingletonCount(), 0);
 398   std::vector<std::thread> threads;
 399   for (int i = 0; i < 100; ++i) {
 400     threads.emplace_back(func);
 401   }
 402   // If circular dependency checks fail, the unlock would trigger a
 403   // crash.  Instead, it succeeds, and we have exactly one living
 404   // singleton.
 405   gatekeeper.unlock();
 406   for (auto& t : threads) {
 407     t.join();
 408   }
 409   EXPECT_EQ(vault.livingSingletonCount(), 1);
 410 }
 411
 412 struct ConcurrencyStressTag {};
 413 template <typename T, typename Tag = detail::DefaultTag>
 414 using SingletonConcurrencyStress = Singleton <T, Tag, ConcurrencyStressTag>;
 415
 416 TEST(Singleton, SingletonConcurrencyStress) {
 417   auto& vault = *SingletonVault::singleton<ConcurrencyStressTag>();
 418   SingletonConcurrencyStress<Slowpoke> slowpoke_singleton;
 419
 420   std::vector<std::thread> ts;
 421   for (size_t i = 0; i < 100; ++i) {
 422     ts.emplace_back([&]() {
 423         slowpoke_singleton.get_weak().lock();
 424       });
 425   }
 426
 427   for (size_t i = 0; i < 100; ++i) {
 428     std::chrono::milliseconds d(20);
 429
 430     std::this_thread::sleep_for(d);
 431     vault.destroyInstances();
 432     std::this_thread::sleep_for(d);
 433     vault.destroyInstances();
 434   }
 435
 436   for (auto& t : ts) {
 437     t.join();
 438   }
 439 }
 440
 441 // Benchmarking a normal singleton vs a Meyers singleton vs a Folly
 442 // singleton.  Meyers are insanely fast, but (hopefully) Folly
 443 // singletons are fast "enough."
 444 int* getMeyersSingleton() {
 445   static auto ret = new int(0);
 446   return ret;
 447 }
 448
 449 int normal_singleton_value = 0;
 450 int* getNormalSingleton() {
 451   doNotOptimizeAway(&normal_singleton_value);
 452   return &normal_singleton_value;
 453 }
 454
 455 struct MockTag {};
 456 template <typename T, typename Tag = detail::DefaultTag>
 457 using SingletonMock = Singleton <T, Tag, MockTag>;
 458
 459 // Verify that existing Singleton's can be overridden
 460 // using the make_mock functionality.
 461 TEST(Singleton, MockTest) {
 462   auto& vault = *SingletonVault::singleton<MockTag>();
 463
 464   SingletonMock<Watchdog> watchdog_singleton;
 465   vault.registrationComplete();
 466
 467   // Registring singletons after registrationComplete called works
 468   // with make_mock (but not with Singleton ctor).
 469   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 470   int serial_count_first = SingletonMock<Watchdog>::get()->serial_number;
 471
 472   // Override existing mock using make_mock.
 473   SingletonMock<Watchdog>::make_mock();
 474
 475   EXPECT_EQ(vault.registeredSingletonCount(), 1);
 476   int serial_count_mock = SingletonMock<Watchdog>::get()->serial_number;
 477
 478   // If serial_count value is the same, then singleton was not replaced.
 479   EXPECT_NE(serial_count_first, serial_count_mock);
 480 }
 481
 482 struct BenchmarkSingleton {
 483   int val = 0;
 484 };
 485
 486 BENCHMARK(NormalSingleton, n) {
 487   for (size_t i = 0; i < n; ++i) {
 488     doNotOptimizeAway(getNormalSingleton());
 489   }
 490 }
 491
 492 BENCHMARK_RELATIVE(MeyersSingleton, n) {
 493   for (size_t i = 0; i < n; ++i) {
 494     doNotOptimizeAway(getMeyersSingleton());
 495   }
 496 }
 497
 498 struct BenchmarkTag {};
 499 template <typename T, typename Tag = detail::DefaultTag>
 500 using SingletonBenchmark = Singleton <T, Tag, BenchmarkTag>;
 501
 502 SingletonBenchmark<BenchmarkSingleton> benchmark_singleton;
 503
 504 BENCHMARK_RELATIVE(FollySingletonSlow, n) {
 505   for (size_t i = 0; i < n; ++i) {
 506     doNotOptimizeAway(SingletonBenchmark<BenchmarkSingleton>::get());
 507   }
 508 }
 509
 510 BENCHMARK_RELATIVE(FollySingletonFast, n) {
 511   for (size_t i = 0; i < n; ++i) {
 512     doNotOptimizeAway(benchmark_singleton.get_fast());
 513   }
 514 }
 515
 516 BENCHMARK_RELATIVE(FollySingletonFastWeak, n) {
 517   for (size_t i = 0; i < n; ++i) {
 518     benchmark_singleton.get_weak_fast();
 519   }
 520 }
 521
 522 int main(int argc, char* argv[]) {
 523   testing::InitGoogleTest(&argc, argv);
 524   google::InitGoogleLogging(argv[0]);
 525   google::ParseCommandLineFlags(&argc, &argv, true);
 526
 527   SingletonVault::singleton()->registrationComplete();
 528
 529   auto ret = RUN_ALL_TESTS();
 530   if (!ret) {
 531     folly::runBenchmarksOnFlag();
 532   }
 533   return ret;
 534 }