HazptrTest.cpp File Reference

#include <folly/synchronization/Hazptr.h>
#include <folly/synchronization/example/HazptrLockFreeLIFO.h>
#include <folly/synchronization/example/HazptrSWMRSet.h>
#include <folly/synchronization/example/HazptrWideCAS.h>
#include <folly/synchronization/test/Barrier.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/GTest.h>
#include <folly/test/DeterministicSchedule.h>
#include <atomic>
#include <thread>

Go to the source code of this file.

Classes
class	Count
class	Node< Atom >
class	NodeRC< Mutable, Atom >
struct	List< T, Atom >
class	NodeAuto< Atom >
class	HazptrPreInitTest

Typedefs
using	DSched = folly::test::DeterministicSchedule

Functions
	DEFINE_bool (bench, false,"run benchmark")
	DEFINE_int64 (num_reps, 10,"Number of test reps")
	DEFINE_int32 (num_threads, 6,"Number of threads")
	DEFINE_int64 (num_ops, 1003,"Number of ops or pairs of ops per rep")
template<template< typename > class Atom = std::atomic>
void	basic_objects_test ()
template<template< typename > class Atom = std::atomic>
void	copy_and_move_test ()
template<template< typename > class Atom = std::atomic>
void	basic_holders_test ()
template<template< typename > class Atom = std::atomic>
void	basic_protection_test ()
template<template< typename > class Atom = std::atomic>
void	virtual_test ()
template<template< typename > class Atom = std::atomic>
void	destruction_test (hazptr_domain< Atom > &domain)
template<template< typename > class Atom = std::atomic>
void	move_test ()
template<template< typename > class Atom = std::atomic>
void	array_test ()
template<template< typename > class Atom = std::atomic>
void	array_dtor_full_tc_test ()
template<template< typename > class Atom = std::atomic>
void	local_test ()
template<bool Mutable, template< typename > class Atom = std::atomic>
void	linked_test ()
template<bool Mutable, template< typename > class Atom = std::atomic>
void	mt_linked_test ()
template<template< typename > class Atom = std::atomic>
void	auto_retire_test ()
template<template< typename > class Atom = std::atomic>
void	free_function_retire_test ()
template<template< typename > class Atom = std::atomic>
void	cleanup_test ()
template<template< typename > class Atom = std::atomic>
void	priv_dtor_test ()
template<template< typename > class Atom = std::atomic>
void	lifo_test ()
template<template< typename > class Atom = std::atomic>
void	swmr_test ()
template<template< typename > class Atom = std::atomic>
void	wide_cas_test ()
	TEST (HazptrTest, basic_objects)
	TEST_F (HazptrPreInitTest, dsched_basic_objects)
	TEST (HazptrTest, copy_and_move)
	TEST_F (HazptrPreInitTest, dsched_copy_and_move)
	TEST (HazptrTest, basic_holders)
	TEST_F (HazptrPreInitTest, dsched_basic_holders)
	TEST (HazptrTest, basic_protection)
	TEST_F (HazptrPreInitTest, dsched_basic_protection)
	TEST (HazptrTest, virtual)
	TEST_F (HazptrPreInitTest, dsched_virtual)
	TEST (HazptrTest, destruction)
	TEST_F (HazptrPreInitTest, dsched_destruction)
	TEST (HazptrTest, move)
	TEST_F (HazptrPreInitTest, dsched_move)
	TEST (HazptrTest, array)
	TEST_F (HazptrPreInitTest, dsched_array)
	TEST (HazptrTest, array_dtor_full_tc)
	TEST_F (HazptrPreInitTest, dsched_array_dtor_full_tc)
	TEST (HazptrTest, local)
	TEST_F (HazptrPreInitTest, dsched_local)
	TEST (HazptrTest, linked_mutable)
	TEST_F (HazptrPreInitTest, dsched_linked_mutable)
	TEST (HazptrTest, linked_immutable)
	TEST_F (HazptrPreInitTest, dsched_linked_immutable)
	TEST (HazptrTest, mt_linked_mutable)
	TEST_F (HazptrPreInitTest, dsched_mt_linked_mutable)
	TEST (HazptrTest, mt_linked_immutable)
	TEST_F (HazptrPreInitTest, dsched_mt_linked_immutable)
	TEST (HazptrTest, auto_retire)
	TEST_F (HazptrPreInitTest, dsched_auto_retire)
	TEST (HazptrTest, free_function_retire)
	TEST_F (HazptrPreInitTest, dsched_free_function_retire)
	TEST (HazptrTest, cleanup)
	TEST_F (HazptrPreInitTest, dsched_cleanup)
	TEST (HazptrTest, priv_dtor)
	TEST_F (HazptrPreInitTest, dsched_priv_dtor)
	TEST (HazptrTest, lifo)
	TEST_F (HazptrPreInitTest, dsched_lifo)
	TEST (HazptrTest, swmr)
	TEST_F (HazptrPreInitTest, dsched_swmr)
	TEST (HazptrTest, wide_cas)
	TEST_F (HazptrPreInitTest, dsched_wide_cas)
	TEST (HazptrTest, reclamation_without_calling_cleanup)
template<typename InitFunc , typename Func , typename EndFunc >
uint64_t	run_once (int nthreads, const InitFunc &init, const Func &fn, const EndFunc &endFn)
template<typename RepFunc >
uint64_t	bench (std::string name, int ops, const RepFunc &repFn)
uint64_t	holder_bench (std::string name, int nthreads)
template<size_t M>
uint64_t	array_bench (std::string name, int nthreads)
template<size_t M>
uint64_t	local_bench (std::string name, int nthreads)
uint64_t	obj_bench (std::string name, int nthreads)
uint64_t	list_hoh_bench (std::string name, int nthreads, int size, bool provided=false)
uint64_t	list_protect_all_bench (std::string name, int nthreads, int size, bool provided=false)
uint64_t	cleanup_bench (std::string name, int nthreads)
void	benches ()
	TEST (HazptrTest, bench)

Variables
static Count	c_
const int	ops = 1000000
const int	nthr [] = {1, 10}
const int	sizes [] = {10, 20}

Typedef Documentation

using DSched = folly::test::DeterministicSchedule

Definition at line 52 of file HazptrTest.cpp.

Function Documentation

template<size_t M>

uint64_t array_bench ( std::string  name, int  nthreads  )

inline

Definition at line 1193 of file HazptrTest.cpp.

References a, bench(), bm::init(), nthreads, ops, and run_once().

                                                          {
  auto repFn = [&] {
    auto init = [] {};
    auto fn = [&](int tid) {
      for (int j = tid; j < 10 * ops; j += nthreads) {
        hazptr_array<M> a;
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<template< typename > class Atom = std::atomic>

void array_dtor_full_tc_test

(

)

Definition at line 456 of file HazptrTest.cpp.

References Atom, M, folly::gen::move, uint8_t, and x.

Referenced by TEST().

                               {
#if FOLLY_HAZPTR_THR_LOCAL
  const uint8_t M = hazptr_tc<Atom>::capacity();
#else
  const uint8_t M = 3;
#endif
  {
    // Fill the thread cache
    hazptr_array<M, Atom> w;
  }
  {
    // Empty array x
    hazptr_array<M, Atom> x(nullptr);
    {
      // y ctor gets elements from the thread cache filled by w dtor.
      hazptr_array<M, Atom> y;
      // z ctor gets elements from the default domain.
      hazptr_array<M, Atom> z;
      // Elements of y are moved to x.
      x = std::move(y);
      // z dtor fills the thread cache.
    }
    // x dtor finds the thread cache full. It has to call
    // ~hazptr_holder() for each of its elements, which were
    // previously taken from the thread cache by y ctor.
  }
}

template<template< typename > class Atom = std::atomic>

void array_test

(

)

Definition at line 436 of file HazptrTest.cpp.

References ASSERT_EQ, Atom, h, i, and folly::gen::move.

Referenced by TEST().

                  {
  for (int i = 0; i < 100; ++i) {
    auto x = new Node<Atom>(i);
    hazptr_array<3, Atom> hptr;
    // Protect object
    hptr[2].reset(x);
    // Empty array
    hazptr_array<3, Atom> h(nullptr);
    // Move assignment
    h = std::move(hptr);
    // Retire object
    x->retire();
    ASSERT_EQ(x->value(), i);
    // Unprotect object - hptr2 is nonempty
    h[2].reset();
  }
  hazptr_cleanup<Atom>();
}

template<template< typename > class Atom = std::atomic>

void auto_retire_test

(

)

Definition at line 607 of file HazptrTest.cpp.

References a, folly::hazptr_obj_linked< Atom >::acquire_link_safe(), ASSERT_EQ, Atom, b, c, Count::clear(), Count::ctors(), Count::dtors(), and h.

Referenced by TEST().

                        {
  c_.clear();
  auto d = new NodeAuto<Atom>;
  d->acquire_link_safe();
  auto c = new NodeAuto<Atom>(d);
  d->acquire_link_safe();
  auto b = new NodeAuto<Atom>(d);
  c->acquire_link_safe();
  b->acquire_link_safe();
  auto a = new NodeAuto<Atom>(b, c);
  hazptr_holder<Atom> h;
  {
    hazptr_root<NodeAuto<Atom>> root;
    a->acquire_link_safe();
    root().store(a);
    ASSERT_EQ(c_.ctors(), 4);
    /* So far the links and link counts are:
           root-->a  a-->b  a-->c  b-->d  c-->d
           a(1,0) b(1,0) c(1,0) d(2,0)
    */
    h.reset(c); /* h protects c */
    hazptr_cleanup<Atom>();
    ASSERT_EQ(c_.dtors(), 0);
    /* Nothing is retired or reclaimed yet */
  }
  /* root dtor calls a->unlink, which calls a->release_link, which
     changes a's link counts from (1,0) to (0,0), which triggers calls
     to c->downgrade_link, b->downgrade_link, and a->retire.

     c->downgrade_link changes c's link counts from (1,0) to (0,1),
     which triggers calls to d->downgrade_link and c->retire.

     d->downgrade_link changes d's link counts from (2,0) to (1,1).

     b->downgrade_link changes b's link counts from (1,0) to (0,1),
     which triggers calls to d->downgrade_link and b->retire.

     d->downgrade_link changes d's link counts from (1,1) to (0,2),
     which triggers a call to d->retire.

     So far (assuming retire-s did not trigger bulk_reclaim):
           a-->b  a-->c  b-->d  c-->d
           a(0,0) b(0,1) c(0,1) d(0,2)
           Retired: a b c d
           Protected: c
  */
  hazptr_cleanup<Atom>();
  /* hazptr_cleanup calls bulk_reclaim which finds a, b, and d
     unprotected, which triggers calls to a->release_ref,
     b->release_ref, and d->release_ref (not necessarily in that
     order).

     a->release_ref finds a's link counts to be (0,0), which triggers
     calls to c->release_ref, b->release_ref and delete a.

     The call to c->release_ref changes its link counts from (0,1) to
     (0,0).

     The first call to b->release_ref changes b's link counts to
     (0,0). The second call finds the link counts to be (0,0), which
     triggers a call to d->release_ref and delete b.

     The first call to d->release_ref changes its link counts to
     (0,1), and the second call changes them to (0,0);

     So far:
           c-->d
           a(deleted) b(deleted) c(0,0) d(0,0)
           Retired and protected: c
           bulk_reclamed-ed (i.e, found not protected): d
  */
  ASSERT_EQ(c_.dtors(), 2);
  h.reset(); /* c is now no longer protected */
  hazptr_cleanup<Atom>();
  /* hazptr_cleanup calls bulk_reclaim which finds c unprotected,
     which triggers a call to c->release_ref.

     c->release_ref finds c's link counts to be (0,0), which
     triggers calls to d->release_ref and delete c.

     d->release_ref finds d's link counts to be (0,0), which triggers
     a call to delete d.

     Finally:
           a(deleted) b(deleted) c(deleted) d(deleted)
  */
  ASSERT_EQ(c_.dtors(), 4);
}

template<template< typename > class Atom = std::atomic>

void basic_holders_test

(

)

Definition at line 347 of file HazptrTest.cpp.

References Atom, and h.

Referenced by TEST().

                          {
  { hazptr_holder<Atom> h; }
  { hazptr_array<2, Atom> h; }
  { hazptr_local<2, Atom> h; }
}

template<template< typename > class Atom = std::atomic>

void basic_objects_test

(

)

Definition at line 280 of file HazptrTest.cpp.

References folly::hazptr_obj_linked< Atom >::acquire_link_safe(), ASSERT_EQ, Atom, Count::clear(), Count::ctors(), Count::dtors(), folly::hazptr_obj_base< T, Atom, D >::retire(), and folly::hazptr_obj_base_linked< T, Atom, D >::retire().

Referenced by TEST().

                          {
  c_.clear();
  int num = 0;
  {
    ++num;
    auto obj = new Node<Atom>;
    obj->retire();
  }
  {
    ++num;
    auto obj = new NodeRC<false, Atom>(0, nullptr);
    obj->retire();
  }
  {
    ++num;
    auto obj = new NodeRC<false, Atom>(0, nullptr);
    obj->acquire_link_safe();
    obj->unlink();
  }
  {
    ++num;
    auto obj = new NodeRC<false, Atom>(0, nullptr);
    obj->acquire_link_safe();
    obj->unlink_and_reclaim_unchecked();
  }
  {
    ++num;
    auto obj = new NodeRC<false, Atom>(0, nullptr);
    obj->acquire_link_safe();
    hazptr_root<NodeRC<false, Atom>> root(obj);
  }
  ASSERT_EQ(c_.ctors(), num);
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), num);
}

template<template< typename > class Atom = std::atomic>

void basic_protection_test

(

)

Definition at line 354 of file HazptrTest.cpp.

References ASSERT_EQ, Atom, Count::clear(), Count::ctors(), Count::dtors(), h, and folly::hazptr_holder< Atom >::reset().

Referenced by TEST().

                             {
  c_.clear();
  auto obj = new Node<Atom>;
  hazptr_holder<Atom> h;
  h.reset(obj);
  obj->retire();
  ASSERT_EQ(c_.ctors(), 1);
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), 0);
  h.reset();
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), 1);
}

template<typename RepFunc >

uint64_t bench	(	std::string	name,
		int	ops,
		const RepFunc &	repFn
	)

Definition at line 1147 of file HazptrTest.cpp.

References max, min, name, string, sum(), uint64_t, and folly::unit.

Referenced by array_bench(), cleanup_bench(), holder_bench(), list_hoh_bench(), list_protect_all_bench(), local_bench(), and obj_bench().

                                                              {
  int reps = 10;
  uint64_t min = UINTMAX_MAX;
  uint64_t max = 0;
  uint64_t sum = 0;

  repFn(); // sometimes first run is outlier
  for (int r = 0; r < reps; ++r) {
    uint64_t dur = repFn();
    sum += dur;
    min = std::min(min, dur);
    max = std::max(max, dur);
  }

  const std::string unit = " ns";
  uint64_t avg = sum / reps;
  uint64_t res = min;
  std::cout << name;
  std::cout << "   " << std::setw(4) << max / ops << unit;
  std::cout << "   " << std::setw(4) << avg / ops << unit;
  std::cout << "   " << std::setw(4) << res / ops << unit;
  std::cout << std::endl;
  return res;
}

void benches

(

)

Definition at line 1308 of file HazptrTest.cpp.

References cleanup_bench(), holder_bench(), i, list_hoh_bench(), list_protect_all_bench(), nthr, obj_bench(), and sizes.

Referenced by TEST().

               {
  for (int i : nthr) {
    std::cout << "================================ " << std::setw(2) << i
              << " threads "
              << "================================" << std::endl;
    std::cout << "10x construct/destruct hazptr_holder          ";
    holder_bench("", i);
    std::cout << "10x construct/destruct hazptr_array<1>        ";
    array_bench<1>("", i);
    std::cout << "10x construct/destruct hazptr_array<2>        ";
    array_bench<2>("", i);
    std::cout << "10x construct/destruct hazptr_array<3>        ";
    array_bench<3>("", i);
    std::cout << "10x construct/destruct hazptr_local<1>        ";
    local_bench<1>("", i);
    std::cout << "10x construct/destruct hazptr_local<2>        ";
    local_bench<2>("", i);
    std::cout << "10x construct/destruct hazptr_local<3>        ";
    local_bench<3>("", i);
    std::cout << "allocate/retire/reclaim object                ";
    obj_bench("", i);
    for (int j : sizes) {
      std::cout << j << "-item list hand-over-hand - own hazptrs     ";
      list_hoh_bench("", i, j, true);
      std::cout << j << "-item list hand-over-hand                   ";
      list_hoh_bench("", i, j);
      std::cout << j << "-item list protect all - own hazptr         ";
      list_protect_all_bench("", i, j, true);
      std::cout << j << "-item list protect all                      ";
      list_protect_all_bench("", i, j);
    }
    std::cout << "hazptr_cleanup                                ";
    cleanup_bench("", i);
  }
}

uint64_t cleanup_bench	(	std::string	name,
		int	nthreads
	)

Definition at line 1290 of file HazptrTest.cpp.

References bench(), folly::hazptr_cleanup(), i, bm::init(), ops, and run_once().

Referenced by benches().

                                                     {
  auto repFn = [&] {
    auto init = [] {};
    auto fn = [&](int) {
      hazptr_holder<std::atomic> hptr;
      for (int i = 0; i < 1000; i++) {
        hazptr_cleanup();
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<template< typename > class Atom = std::atomic>

void cleanup_test

(

)

Definition at line 720 of file HazptrTest.cpp.

References ASSERT_EQ, Atom, Count::clear(), Count::ctors(), Count::dtors(), h, i, folly::test::DeterministicSchedule::join(), folly::hazptr_obj_base< T, Atom, D >::retire(), folly::pushmi::detail::t, folly::test::DeterministicSchedule::thread(), and threads.

Referenced by TEST().

                    {
  int threadOps = 1007;
  int mainOps = 19;
  c_.clear();
  Atom<int> threadsDone{0};
  Atom<bool> mainDone{false};
  std::vector<std::thread> threads(FLAGS_num_threads);
  for (int tid = 0; tid < FLAGS_num_threads; ++tid) {
    threads[tid] = DSched::thread([&, tid]() {
      for (int j = tid; j < threadOps; j += FLAGS_num_threads) {
        auto p = new Node<Atom>;
        p->retire();
      }
      threadsDone.fetch_add(1);
      while (!mainDone.load()) {
        /* spin */;
      }
    });
  }
  { // include the main thread in the test
    for (int i = 0; i < mainOps; ++i) {
      auto p = new Node<Atom>;
      p->retire();
    }
  }
  while (threadsDone.load() < FLAGS_num_threads) {
    /* spin */;
  }
  ASSERT_EQ(c_.ctors(), threadOps + mainOps);
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), threadOps + mainOps);
  mainDone.store(true);
  for (auto& t : threads) {
    DSched::join(t);
  }
  { // Cleanup after using array
    c_.clear();
    { hazptr_array<2, Atom> h; }
    {
      hazptr_array<2, Atom> h;
      auto p0 = new Node<Atom>;
      auto p1 = new Node<Atom>;
      h[0].reset(p0);
      h[1].reset(p1);
      p0->retire();
      p1->retire();
    }
    ASSERT_EQ(c_.ctors(), 2);
    hazptr_cleanup<Atom>();
    ASSERT_EQ(c_.dtors(), 2);
  }
  { // Cleanup after using local
    c_.clear();
    { hazptr_local<2, Atom> h; }
    {
      hazptr_local<2, Atom> h;
      auto p0 = new Node<Atom>;
      auto p1 = new Node<Atom>;
      h[0].reset(p0);
      h[1].reset(p1);
      p0->retire();
      p1->retire();
    }
    ASSERT_EQ(c_.ctors(), 2);
    hazptr_cleanup<Atom>();
    ASSERT_EQ(c_.dtors(), 2);
  }
}

template<template< typename > class Atom = std::atomic>

void copy_and_move_test

(

)

Definition at line 317 of file HazptrTest.cpp.

References a, Atom, and folly::gen::move.

Referenced by TEST().

                          {
  struct Obj : hazptr_obj_base<Obj, Atom> {
    int a;
  };

  auto p1 = new Obj();
  auto p2 = new Obj(*p1);
  p1->retire();
  p2->retire();

  p1 = new Obj();
  p2 = new Obj(std::move(*p1));
  p1->retire();
  p2->retire();

  p1 = new Obj();
  p2 = new Obj();
  *p2 = *p1;
  p1->retire();
  p2->retire();

  p1 = new Obj();
  p2 = new Obj();
  *p2 = std::move(*p1);
  p1->retire();
  p2->retire();
  hazptr_cleanup<Atom>();
}

DEFINE_bool	(	bench	,
		false	,
		"run benchmark"
	)

DEFINE_int32	(	num_threads	,
		6	,
		"Number of threads"
	)

DEFINE_int64	(	num_reps	,
		10	,
		"Number of test reps"
	)

DEFINE_int64	(	num_ops	,
		1003	,
		"Number of ops or pairs of ops per rep"
	)

template<template< typename > class Atom = std::atomic>

void destruction_test

(

hazptr_domain< Atom > &

domain

)

Definition at line 387 of file HazptrTest.cpp.

References Atom, i, cpp.ast::next(), and val.

Referenced by TEST().

                                                   {
  struct Thing : public hazptr_obj_base<Thing, Atom> {
    Thing* next;
    hazptr_domain<Atom>* domain;
    int val;
    Thing(int v, Thing* n, hazptr_domain<Atom>* d)
        : next(n), domain(d), val(v) {}
    ~Thing() {
      if (next) {
        next->retire(*domain);
      }
    }
  };
  Thing* last{nullptr};
  for (int i = 0; i < 2000; i++) {
    last = new Thing(i, last, &domain);
  }
  last->retire(domain);
  hazptr_cleanup<Atom>();
}

template<template< typename > class Atom = std::atomic>

void free_function_retire_test

(

)

Definition at line 697 of file HazptrTest.cpp.

References ASSERT_TRUE, Atom, testing::gmock_matchers_test::foo, foo2(), and folly::hazptr_domain< Atom >::retire().

Referenced by TEST().

                                 {
  auto foo = new int;
  hazptr_retire<Atom>(foo);
  auto foo2 = new int;
  hazptr_retire<Atom>(foo2, [](int* obj) { delete obj; });

  bool retired = false;
  {
    hazptr_domain<Atom> myDomain0;
    struct delret {
      bool* retired_;
      explicit delret(bool* retire) : retired_(retire) {}
      ~delret() {
        *retired_ = true;
      }
    };
    auto foo3 = new delret(&retired);
    myDomain0.retire(foo3);
  }
  ASSERT_TRUE(retired);
}

uint64_t holder_bench ( std::string  name, int  nthreads  )

inline

Definition at line 1178 of file HazptrTest.cpp.

References bench(), h, bm::init(), nthreads, ops, and run_once().

Referenced by benches().

                                                           {
  auto repFn = [&] {
    auto init = [] {};
    auto fn = [&](int tid) {
      for (int j = tid; j < 10 * ops; j += nthreads) {
        hazptr_holder<> h;
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<template< typename > class Atom = std::atomic>

void lifo_test

(

)

Definition at line 813 of file HazptrTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, Atom, i, folly::test::DeterministicSchedule::join(), folly::fibers::local(), folly::HazptrLockFreeLIFO< T, Atom >::pop(), folly::HazptrLockFreeLIFO< T, Atom >::push(), s, sum(), folly::pushmi::detail::t, folly::test::DeterministicSchedule::thread(), threads, and v.

Referenced by TEST().

                 {
  for (int i = 0; i < FLAGS_num_reps; ++i) {
    Atom<int> sum{0};
    HazptrLockFreeLIFO<int, Atom> s;
    std::vector<std::thread> threads(FLAGS_num_threads);
    for (int tid = 0; tid < FLAGS_num_threads; ++tid) {
      threads[tid] = DSched::thread([&, tid]() {
        int local = 0;
        for (int j = tid; j < FLAGS_num_ops; j += FLAGS_num_threads) {
          s.push(j);
          int v;
          ASSERT_TRUE(s.pop(v));
          local += v;
        }
        sum.fetch_add(local);
      });
    }
    for (auto& t : threads) {
      DSched::join(t);
    }
    hazptr_cleanup<Atom>();
    int expected = FLAGS_num_ops * (FLAGS_num_ops - 1) / 2;
    ASSERT_EQ(sum.load(), expected);
  }
}

template<bool Mutable, template< typename > class Atom = std::atomic>

void linked_test

(

)

Definition at line 500 of file HazptrTest.cpp.

References ASSERT_EQ, ASSERT_GT, Atom, Count::clear(), Count::ctors(), Count::dtors(), i, folly::gen::Mutable, NodeRC< Mutable, Atom >::next(), folly::hazptr_obj_base_linked< NodeRC< Mutable, Atom >, Atom >::retire(), and v.

                   {
  c_.clear();
  NodeRC<Mutable, Atom>* p = nullptr;
  int num = 193;
  for (int i = 0; i < num - 1; ++i) {
    p = new NodeRC<Mutable, Atom>(i, p, true);
  }
  p = new NodeRC<Mutable, Atom>(num - 1, p, Mutable);
  hazptr_holder<Atom> hptr;
  hptr.reset(p);
  if (!Mutable) {
    for (auto q = p->next(); q; q = q->next()) {
      q->retire();
    }
  }
  int v = num;
  for (auto q = p; q; q = q->next()) {
    ASSERT_GT(v, 0);
    --v;
    ASSERT_EQ(q->value(), v);
  }

  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.ctors(), num);
  ASSERT_EQ(c_.dtors(), 0);

  if (Mutable) {
    hazptr_root<NodeRC<Mutable, Atom>, Atom> root(p);
  } else {
    p->retire();
  }
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), 0);

  hptr.reset();
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), num);
}

uint64_t list_hoh_bench	(	std::string	name,
		int	nthreads,
		int	size,
		bool	provided = false
	)

Definition at line 1238 of file HazptrTest.cpp.

References bench(), List< T, Atom >::hand_over_hand(), bm::init(), nthreads, ops, and run_once().

Referenced by benches().

                           {
  auto repFn = [&] {
    List<Node<>> l(size);
    auto init = [&] {};
    auto fn = [&](int tid) {
      if (provided) {
        hazptr_local<2> hptr;
        for (int j = tid; j < ops; j += nthreads) {
          l.hand_over_hand(size, &hptr[0], &hptr[1]);
        }
      } else {
        for (int j = tid; j < ops; j += nthreads) {
          l.hand_over_hand(size);
        }
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

uint64_t list_protect_all_bench	(	std::string	name,
		int	nthreads,
		int	size,
		bool	provided = false
	)

Definition at line 1264 of file HazptrTest.cpp.

References bench(), bm::init(), nthreads, ops, List< T, Atom >::protect_all(), and run_once().

Referenced by benches().

                           {
  auto repFn = [&] {
    List<NodeRC<true>> l(size);
    auto init = [] {};
    auto fn = [&](int tid) {
      if (provided) {
        hazptr_local<1> hptr;
        for (int j = tid; j < ops; j += nthreads) {
          l.protect_all(size, hptr[0]);
        }
      } else {
        for (int j = tid; j < ops; j += nthreads) {
          l.protect_all(size);
        }
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<size_t M>

uint64_t local_bench ( std::string  name, int  nthreads  )

inline

Definition at line 1208 of file HazptrTest.cpp.

References a, bench(), bm::init(), nthreads, ops, and run_once().

                                                          {
  auto repFn = [&] {
    auto init = [] {};
    auto fn = [&](int tid) {
      for (int j = tid; j < 10 * ops; j += nthreads) {
        hazptr_local<M> a;
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<template< typename > class Atom = std::atomic>

void local_test

(

)

Definition at line 485 of file HazptrTest.cpp.

References Atom, and i.

Referenced by TEST().

                  {
  for (int i = 0; i < 100; ++i) {
    auto x = new Node<Atom>(i);
    hazptr_local<3, Atom> hptr;
    // Protect object
    hptr[2].reset(x);
    // Retire object
    x->retire();
    // Unprotect object - hptr2 is nonempty
    hptr[2].reset();
  }
  hazptr_cleanup<Atom>();
}

template<template< typename > class Atom = std::atomic>

void move_test

(

)

Definition at line 409 of file HazptrTest.cpp.

References ASSERT_EQ, Atom, i, folly::gen::move, and folly::hazptr_holder< Atom >::reset().

Referenced by TEST().

                 {
  for (int i = 0; i < 100; ++i) {
    auto x = new Node<Atom>(i);
    hazptr_holder<Atom> hptr0;
    // Protect object
    hptr0.reset(x);
    // Retire object
    x->retire();
    // Move constructor - still protected
    hazptr_holder<Atom> hptr1(std::move(hptr0));
    // Self move is no-op - still protected
    auto phptr1 = &hptr1;
    ASSERT_EQ(phptr1, &hptr1);
    hptr1 = std::move(*phptr1);
    // Empty constructor
    hazptr_holder<Atom> hptr2(nullptr);
    // Move assignment - still protected
    hptr2 = std::move(hptr1);
    // Access object
    ASSERT_EQ(x->value(), i);
    // Unprotect object - hptr2 is nonempty
    hptr2.reset();
  }
  hazptr_cleanup<Atom>();
}

template<bool Mutable, template< typename > class Atom = std::atomic>

void mt_linked_test

(

)

Definition at line 540 of file HazptrTest.cpp.

References ASSERT_EQ, ASSERT_GT, Atom, Count::clear(), Count::ctors(), Count::dtors(), folly::hazptr_holder< Atom >::get_protected(), i, folly::test::DeterministicSchedule::join(), folly::gen::Mutable, NodeRC< Mutable, Atom >::next(), nthr, folly::pushmi::detail::t, folly::test::DeterministicSchedule::thread(), folly::hazptr_obj_base_linked< NodeRC< Mutable, Atom >, Atom >::unlink(), and v.

                      {
  c_.clear();

  Atom<bool> ready(false);
  Atom<bool> done(false);
  Atom<int> setHazptrs(0);
  hazptr_root<NodeRC<Mutable, Atom>, Atom> head;

  int num = FLAGS_num_ops;
  int nthr = FLAGS_num_threads;
  ASSERT_GT(FLAGS_num_threads, 0);
  std::vector<std::thread> thr(nthr);
  for (int i = 0; i < nthr; ++i) {
    thr[i] = DSched::thread([&] {
      while (!ready.load()) {
        /* spin */
      }
      hazptr_holder<Atom> hptr;
      auto p = hptr.get_protected(head());
      ++setHazptrs;
      /* Concurrent with removal */
      int v = num;
      for (auto q = p; q; q = q->next()) {
        ASSERT_GT(v, 0);
        --v;
        ASSERT_EQ(q->value(), v);
      }
      ASSERT_EQ(v, 0);
      while (!done.load()) {
        /* spin */
      }
    });
  }

  NodeRC<Mutable, Atom>* p = nullptr;
  for (int i = 0; i < num - 1; ++i) {
    p = new NodeRC<Mutable, Atom>(i, p, true);
  }
  p = new NodeRC<Mutable, Atom>(num - 1, p, Mutable);
  ASSERT_EQ(c_.ctors(), num);
  head().store(p);
  ready.store(true);
  while (setHazptrs.load() < nthr) {
    /* spin */
  }

  /* this is concurrent with traversal by readers */
  head().store(nullptr);
  if (Mutable) {
    p->unlink();
  } else {
    for (auto q = p; q; q = q->next()) {
      q->retire();
    }
  }
  ASSERT_EQ(c_.dtors(), 0);
  done.store(true);

  for (auto& t : thr) {
    DSched::join(t);
  }

  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), num);
}

uint64_t obj_bench ( std::string  name, int  nthreads  )

inline

Definition at line 1222 of file HazptrTest.cpp.

References bench(), bm::init(), nthreads, ops, and run_once().

Referenced by benches().

                                                        {
  struct Foo : public hazptr_obj_base<Foo> {};
  auto repFn = [&] {
    auto init = [] {};
    auto fn = [&](int tid) {
      for (int j = tid; j < ops; j += nthreads) {
        auto p = new Foo;
        p->retire();
      }
    };
    auto endFn = [] {};
    return run_once(nthreads, init, fn, endFn);
  };
  return bench(name, ops, repFn);
}

template<template< typename > class Atom = std::atomic>

void priv_dtor_test

(

)

Definition at line 790 of file HazptrTest.cpp.

References ASSERT_EQ, Atom, Count::clear(), Count::ctors(), Count::dtors(), folly::test::DeterministicSchedule::join(), and folly::test::DeterministicSchedule::thread().

Referenced by TEST().

                      {
  c_.clear();
  using NodeT = NodeRC<true, Atom>;
  auto y = new NodeT;
  y->acquire_link_safe();
  struct Foo : hazptr_obj_base<Foo, Atom> {
    hazptr_root<NodeT, Atom> r_;
  };
  auto x = new Foo;
  x->r_().store(y);
  /* Thread retires x. Dtor of TLS priv list pushes x to domain, which
     triggers bulk reclaim due to timed cleanup (when the test is run
     by itself). Reclamation of x unlinks and retires y. y should
     not be pushed into the thread's priv list. It should be pushed to
     domain instead. */
  auto thr = DSched::thread([&]() { x->retire(); });
  DSched::join(thr);
  ASSERT_EQ(c_.ctors(), 1);
  hazptr_cleanup<Atom>();
  ASSERT_EQ(c_.dtors(), 1);
}

template<typename InitFunc , typename Func , typename EndFunc >

uint64_t run_once	(	int	nthreads,
		const InitFunc &	init,
		const Func &	fn,
		const EndFunc &	endFn
	)

Definition at line 1116 of file HazptrTest.cpp.

References b, count, folly::hazptr_cleanup(), bm::init(), now(), nthreads, start, folly::pushmi::detail::t, threads, and folly::test::Barrier::wait().

Referenced by array_bench(), cleanup_bench(), holder_bench(), list_hoh_bench(), list_protect_all_bench(), local_bench(), and obj_bench().

                          {
  std::atomic<bool> start{false};
  Barrier b(nthreads + 1);
  init();
  std::vector<std::thread> threads(nthreads);
  for (int tid = 0; tid < nthreads; ++tid) {
    threads[tid] = std::thread([&, tid] {
      b.wait();
      fn(tid);
    });
  }
  b.wait();
  // begin time measurement
  auto tbegin = std::chrono::steady_clock::now();
  start.store(true);
  for (auto& t : threads) {
    t.join();
  }
  hazptr_cleanup();
  // end time measurement
  auto tend = std::chrono::steady_clock::now();
  endFn();
  return std::chrono::duration_cast<std::chrono::nanoseconds>(tend - tbegin)
      .count();
}

template<template< typename > class Atom = std::atomic>

void swmr_test

(

)

Definition at line 840 of file HazptrTest.cpp.

References folly::HazptrSWMRSet< T, Atom >::add(), Atom, folly::HazptrSWMRSet< T, Atom >::contains(), i, folly::test::DeterministicSchedule::join(), folly::HazptrSWMRSet< T, Atom >::remove(), s, folly::pushmi::detail::t, T, folly::test::DeterministicSchedule::thread(), threads, and uint64_t.

Referenced by TEST().

                 {
  using T = uint64_t;
  for (int i = 0; i < FLAGS_num_reps; ++i) {
    HazptrSWMRSet<T, Atom> s;
    std::vector<std::thread> threads(FLAGS_num_threads);
    for (int tid = 0; tid < FLAGS_num_threads; ++tid) {
      threads[tid] = DSched::thread([&s, tid]() {
        for (int j = tid; j < FLAGS_num_ops; j += FLAGS_num_threads) {
          s.contains(j);
        }
      });
    }
    for (int j = 0; j < 10; ++j) {
      s.add(j);
    }
    for (int j = 0; j < 10; ++j) {
      s.remove(j);
    }
    for (auto& t : threads) {
      DSched::join(t);
    }
    hazptr_cleanup<Atom>();
  }
}

TEST	(	HazptrTest	,
		basic_objects
	)

Definition at line 896 of file HazptrTest.cpp.

References basic_objects_test().

                                {
  basic_objects_test();
}

TEST	(	HazptrTest	,
		copy_and_move
	)

Definition at line 905 of file HazptrTest.cpp.

References copy_and_move_test().

                                {
  copy_and_move_test();
}

TEST	(	HazptrTest	,
		basic_holders
	)

Definition at line 914 of file HazptrTest.cpp.

References basic_holders_test().

                                {
  basic_holders_test();
}

TEST	(	HazptrTest	,
		basic_protection
	)

Definition at line 923 of file HazptrTest.cpp.

References basic_protection_test().

                                   {
  basic_protection_test();
}

TEST	(	HazptrTest	,
		virtual
	)

Definition at line 932 of file HazptrTest.cpp.

References virtual_test().

                          {
  virtual_test();
}

TEST	(	HazptrTest	,
		destruction
	)

Definition at line 941 of file HazptrTest.cpp.

References destruction_test().

                              {
  {
    hazptr_domain<> myDomain0;
    destruction_test(myDomain0);
  }
  destruction_test(default_hazptr_domain<std::atomic>());
}

TEST	(	HazptrTest	,
		move
	)

Definition at line 959 of file HazptrTest.cpp.

References move_test().

                       {
  move_test();
}

TEST	(	HazptrTest	,
		array
	)

Definition at line 968 of file HazptrTest.cpp.

References array_test().

                        {
  array_test();
}

TEST	(	HazptrTest	,
		array_dtor_full_tc
	)

Definition at line 977 of file HazptrTest.cpp.

References array_dtor_full_tc_test().

                                     {
  array_dtor_full_tc_test();
}

TEST	(	HazptrTest	,
		local
	)

Definition at line 986 of file HazptrTest.cpp.

References local_test().

                        {
  local_test();
}

TEST	(	HazptrTest	,
		linked_mutable
	)

Definition at line 995 of file HazptrTest.cpp.

                                 {
  linked_test<true>();
}

TEST	(	HazptrTest	,
		linked_immutable
	)

Definition at line 1004 of file HazptrTest.cpp.

                                   {
  linked_test<false>();
}

TEST	(	HazptrTest	,
		mt_linked_mutable
	)

Definition at line 1013 of file HazptrTest.cpp.

                                    {
  mt_linked_test<true>();
}

TEST	(	HazptrTest	,
		mt_linked_immutable
	)

Definition at line 1022 of file HazptrTest.cpp.

                                      {
  mt_linked_test<false>();
}

TEST	(	HazptrTest	,
		auto_retire
	)

Definition at line 1031 of file HazptrTest.cpp.

References auto_retire_test().

                              {
  auto_retire_test();
}

TEST	(	HazptrTest	,
		free_function_retire
	)

Definition at line 1040 of file HazptrTest.cpp.

References free_function_retire_test().

                                       {
  free_function_retire_test();
}

TEST	(	HazptrTest	,
		cleanup
	)

Definition at line 1049 of file HazptrTest.cpp.

References cleanup_test().

                          {
  cleanup_test();
}

TEST	(	HazptrTest	,
		priv_dtor
	)

Definition at line 1058 of file HazptrTest.cpp.

References priv_dtor_test().

                            {
  priv_dtor_test();
}

TEST	(	HazptrTest	,
		lifo
	)

Definition at line 1067 of file HazptrTest.cpp.

References lifo_test().

                       {
  lifo_test();
}

TEST	(	HazptrTest	,
		swmr
	)

Definition at line 1076 of file HazptrTest.cpp.

References swmr_test().

                       {
  swmr_test();
}

TEST	(	HazptrTest	,
		wide_cas
	)

Definition at line 1085 of file HazptrTest.cpp.

References wide_cas_test().

                           {
  wide_cas_test();
}

TEST	(	HazptrTest	,
		reclamation_without_calling_cleanup
	)

Definition at line 1094 of file HazptrTest.cpp.

References ASSERT_GT, Count::clear(), Count::dtors(), folly::detail::hazptr_domain_rcount_threshold(), i, nthr, folly::hazptr_obj_base< T, Atom, D >::retire(), and folly::pushmi::detail::t.

                                                      {
  c_.clear();
  int nthr = 5;
  int objs = folly::detail::hazptr_domain_rcount_threshold();
  std::vector<std::thread> thr(nthr);
  for (int tid = 0; tid < nthr; ++tid) {
    thr[tid] = std::thread([&, tid] {
      for (int i = tid; i < objs; i += nthr) {
        auto p = new Node<>;
        p->retire();
      }
    });
  }
  for (auto& t : thr) {
    t.join();
  }
  ASSERT_GT(c_.dtors(), 0);
}

TEST	(	HazptrTest	,
		bench
	)

Definition at line 1344 of file HazptrTest.cpp.

References benches().

                        {
  if (FLAGS_bench) {
    benches();
  }
}

TEST_F	(	HazptrPreInitTest	,
		dsched_basic_objects
	)

Definition at line 900 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                {
  DSched sched(DSched::uniform(0));
  basic_objects_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_copy_and_move
	)

Definition at line 909 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                {
  DSched sched(DSched::uniform(0));
  copy_and_move_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_basic_holders
	)

Definition at line 918 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                {
  DSched sched(DSched::uniform(0));
  basic_holders_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_basic_protection
	)

Definition at line 927 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                   {
  DSched sched(DSched::uniform(0));
  basic_protection_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_virtual
	)

Definition at line 936 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                          {
  DSched sched(DSched::uniform(0));
  virtual_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_destruction
	)

Definition at line 949 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                              {
  DSched sched(DSched::uniform(0));
  {
    hazptr_domain<DeterministicAtomic> myDomain0;
    destruction_test<DeterministicAtomic>(myDomain0);
  }
  destruction_test<DeterministicAtomic>(
      default_hazptr_domain<DeterministicAtomic>());
}

TEST_F	(	HazptrPreInitTest	,
		dsched_move
	)

Definition at line 963 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                       {
  DSched sched(DSched::uniform(0));
  move_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_array
	)

Definition at line 972 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                        {
  DSched sched(DSched::uniform(0));
  array_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_array_dtor_full_tc
	)

Definition at line 981 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                     {
  DSched sched(DSched::uniform(0));
  array_dtor_full_tc_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_local
	)

Definition at line 990 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                        {
  DSched sched(DSched::uniform(0));
  local_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_linked_mutable
	)

Definition at line 999 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                 {
  DSched sched(DSched::uniform(0));
  linked_test<true, DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_linked_immutable
	)

Definition at line 1008 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                   {
  DSched sched(DSched::uniform(0));
  linked_test<false, DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_mt_linked_mutable
	)

Definition at line 1017 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                    {
  DSched sched(DSched::uniform(0));
  mt_linked_test<true, DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_mt_linked_immutable
	)

Definition at line 1026 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                      {
  DSched sched(DSched::uniform(0));
  mt_linked_test<false, DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_auto_retire
	)

Definition at line 1035 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                              {
  DSched sched(DSched::uniform(0));
  auto_retire_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_free_function_retire
	)

Definition at line 1044 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                                       {
  DSched sched(DSched::uniform(0));
  free_function_retire_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_cleanup
	)

Definition at line 1053 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                          {
  DSched sched(DSched::uniform(0));
  cleanup_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_priv_dtor
	)

Definition at line 1062 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                            {
  DSched sched(DSched::uniform(0));
  priv_dtor_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_lifo
	)

Definition at line 1071 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                       {
  DSched sched(DSched::uniform(0));
  lifo_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_swmr
	)

Definition at line 1080 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                       {
  DSched sched(DSched::uniform(0));
  swmr_test<DeterministicAtomic>();
}

TEST_F	(	HazptrPreInitTest	,
		dsched_wide_cas
	)

Definition at line 1089 of file HazptrTest.cpp.

References folly::test::DeterministicSchedule::uniform().

                                           {
  DSched sched(DSched::uniform(0));
  wide_cas_test<DeterministicAtomic>();
}

template<template< typename > class Atom = std::atomic>

void virtual_test

(

)

Definition at line 369 of file HazptrTest.cpp.

References a, ASSERT_EQ, Atom, i, and folly::hazptr_holder< Atom >::reset().

Referenced by TEST().

                    {
  struct Thing : public hazptr_obj_base<Thing, Atom> {
    virtual ~Thing() {}
    int a;
  };
  for (int i = 0; i < 100; i++) {
    auto bar = new Thing;
    bar->a = i;

    hazptr_holder<Atom> hptr;
    hptr.reset(bar);
    bar->retire();
    ASSERT_EQ(bar->a, i);
  }
  hazptr_cleanup<Atom>();
}

template<template< typename > class Atom = std::atomic>

void wide_cas_test

(

)

Definition at line 866 of file HazptrTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, folly::HazptrWideCAS< T, Atom >::cas(), s, and string.

Referenced by TEST().

                     {
  HazptrWideCAS<std::string, Atom> s;
  std::string u = "";
  std::string v = "11112222";
  auto ret = s.cas(u, v);
  ASSERT_TRUE(ret);
  u = "";
  v = "11112222";
  ret = s.cas(u, v);
  ASSERT_FALSE(ret);
  u = "11112222";
  v = "22223333";
  ret = s.cas(u, v);
  ASSERT_TRUE(ret);
  u = "22223333";
  v = "333344445555";
  ret = s.cas(u, v);
  ASSERT_TRUE(ret);
  hazptr_cleanup<Atom>();
}

Variable Documentation

Count c_

static

Definition at line 94 of file HazptrTest.cpp.

Referenced by folly::padded::Adaptor< IntNodeVec >::allocate_back(), folly::padded::Adaptor< IntNodeVec >::back(), folly::padded::Adaptor< IntNodeVec >::begin(), folly::padded::Adaptor< IntNodeVec >::capacity(), folly::padded::Adaptor< IntNodeVec >::cbegin(), folly::padded::Adaptor< IntNodeVec >::cend(), folly::padded::Adaptor< IntNodeVec >::clear(), folly::padded::Adaptor< IntNodeVec >::empty(), folly::padded::Adaptor< IntNodeVec >::end(), folly::padded::Adaptor< IntNodeVec >::front(), folly::padded::Adaptor< IntNodeVec >::max_size(), folly::padded::Adaptor< IntNodeVec >::move(), folly::padded::Adaptor< IntNodeVec >::operator=(), folly::padded::Adaptor< IntNodeVec >::operator[](), folly::padded::Adaptor< IntNodeVec >::padToFullNode(), folly::padded::Adaptor< IntNodeVec >::peek(), folly::padded::Adaptor< IntNodeVec >::pop_back(), folly::padded::Adaptor< IntNodeVec >::reserve(), folly::padded::Adaptor< IntNodeVec >::size(), folly::padded::Adaptor< IntNodeVec >::swap(), and testing::gmock_matchers_test::Unprintable::Unprintable().

const int nthr[] = {1, 10}

Definition at line 1305 of file HazptrTest.cpp.

Referenced by benches(), mt_linked_test(), and TEST().

const int ops = 1000000

Definition at line 1176 of file HazptrTest.cpp.

Referenced by array_bench(), bench(), cleanup_bench(), concurrentOps(), concurrentSizeTest(), enq_deq_test(), folly::test::fc_test(), holder_bench(), list_hoh_bench(), list_protect_all_bench(), local_bench(), multiPusherPopper(), obj_bench(), producer_consumer_test(), run_once(), folly::test::run_test(), test(), TEST(), test_scan(), and throughtput_test().

const int sizes[] = {10, 20}

Definition at line 1306 of file HazptrTest.cpp.

Referenced by benches(), folly::getHugePageSizes(), folly::test::TEST(), TEST(), and testSimple().