19 #ifdef FOLLY_USE_LIBSTDCPP 31 using namespace folly;
34 static int c_count{0};
35 static int d_count{0};
51 TEST(AtomicSharedPtr, operators) {
55 std::shared_ptr<int>
s(i);
57 shared_ptr<int>
bar(fooptr);
65 auto a = make_shared<int>(1);
67 auto b = fooptr.
exchange(make_shared<int>());
76 fooptr.
store(make_shared<foo>());
80 auto res = fooptr.
load();
91 TEST(AtomicSharedPtr, counted) {
97 fooptr.
store(make_counted<std::atomic, foo>());
101 auto res = fooptr.
load();
112 TEST(AtomicSharedPtr, counted2) {
113 auto foo = make_counted<std::atomic, bool>();
120 TEST(AtomicSharedPtr, ConstTest) {
121 const auto a(std::make_shared<foo>());
127 TEST(AtomicSharedPtr, AliasingConstructorTest) {
130 auto a = std::make_shared<foo>();
132 auto alias = std::shared_ptr<foo>(
a,
b);
138 auto res1 = asp.load();
139 auto res2 = asp.exchange(
nullptr);
153 TEST(AtomicSharedPtr, MaxPtrs) {
154 shared_ptr<long> p(
new long);
155 int max_atomic_shared_ptrs = 262144;
157 for (
int i = 0; i < max_atomic_shared_ptrs - 1; i++) {
161 EXPECT_DEATH(fail.
store(p),
"");
164 TEST(AtomicSharedPtr, DeterministicTest) {
167 auto foo = make_counted<DeterministicAtomic, bool>();
173 std::vector<std::thread>
threads(FLAGS_num_threads);
174 for (
int tid = 0; tid < FLAGS_num_threads; ++tid) {
176 for (
int i = 0; i < 1000; i++) {
177 auto l = fooptr.
load();
180 fooptr.
store(make_counted<DeterministicAtomic, bool>());
182 l, make_counted<DeterministicAtomic, bool>()));
190 #endif // #ifdef FOLLY_USE_LIBSTDCPP
SharedPtr load(std::memory_order order=std::memory_order_seq_cst) const noexcept
#define EXPECT_EQ(val1, val2)
constexpr detail::Map< Move > move
DeterministicAtomicImpl< T, DeterministicSchedule > DeterministicAtomic
SharedPtr exchange(SharedPtr n, std::memory_order order=std::memory_order_seq_cst)
static std::thread thread(Func &&func, Args &&...args)
—— Concurrent Priority Queue Implementation ——
DEFINE_int64(threadtimeout_ms, 60000,"Idle time before ThreadPoolExecutor threads are joined")
std::vector< std::thread::id > threads
static std::function< size_t(size_t)> uniform(uint64_t seed)
bool compare_exchange_strong(SharedPtr &expected, const SharedPtr &n, std::memory_order mo=std::memory_order_seq_cst) noexcept
folly::Singleton< int > bar
TEST(ProgramOptionsTest, Errors)
#define EXPECT_TRUE(condition)
T exchange(T &obj, U &&new_value)
#define DEFINE_int32(_name, _default, _description)
bool is_lock_free() const noexcept
void store(SharedPtr n, std::memory_order order=std::memory_order_seq_cst)
#define EXPECT_FALSE(condition)
static void join(std::thread &child)