folly::f14 Namespace Reference

Namespaces
	detail

Classes
struct	Counts
class	GenericAlloc
class	GenericEqual
class	GenericHasher
struct	Histo
struct	MoveOnlyTestInt
class	SwapTrackingAlloc
struct	Tracked
struct	TransparentTrackedEqual
struct	TransparentTrackedHash

Typedefs
template<typename T >
using	DefaultHasher = HeterogeneousAccessHash< T >
template<typename T >
using	DefaultKeyEqual = HeterogeneousAccessEqualTo< T >
template<typename T >
using	DefaultAlloc = std::allocator< T >

Functions
std::ostream &	operator<< (std::ostream &xo, Histo const &histo)
void	accumulate (std::vector< std::size_t > &a, std::vector< std::size_t > const &d)
double	expectedProbe (std::vector< std::size_t > const &probeLengths)
std::size_t	p99Probe (std::vector< std::size_t > const &probeLengths)
std::ostream &	operator<< (std::ostream &xo, Counts const &counts)
void	limitTestAllocations (std::size_t allocationsBeforeException=0)
void	unlimitTestAllocations ()
void	resetTracking ()
template<class T >
void	swap (SwapTrackingAlloc< T > &, SwapTrackingAlloc< T > &)
template<class T1 , class T2 >
bool	operator== (SwapTrackingAlloc< T1 > const &, SwapTrackingAlloc< T2 > const &)
template<class T1 , class T2 >
bool	operator!= (SwapTrackingAlloc< T1 > const &, SwapTrackingAlloc< T2 > const &)
std::ostream &	operator<< (std::ostream &xo, F14TableStats const &stats)

Variables
thread_local Counts	sumCounts {}
thread_local size_t	testAllocatedMemorySize {0}
thread_local size_t	testAllocatedBlockCount {0}
thread_local size_t	testAllocationCount {0}
thread_local size_t	testAllocationMaxCount

Typedef Documentation

template<typename T >

using folly::f14::DefaultAlloc = typedef std::allocator<T>

Definition at line 32 of file F14Defaults.h.

template<typename T >

using folly::f14::DefaultHasher = typedef HeterogeneousAccessHash<T>

Definition at line 26 of file F14Defaults.h.

template<typename T >

using folly::f14::DefaultKeyEqual = typedef HeterogeneousAccessEqualTo<T>

Definition at line 29 of file F14Defaults.h.

Function Documentation

void folly::f14::accumulate	(	std::vector< std::size_t > &	a,
		std::vector< std::size_t > const &	d
	)

Definition at line 58 of file F14TestUtil.h.

References i.

Referenced by BENCHMARK(), TestData::checkIn(), TestData::checkOut(), folly::dynamic::hash(), main(), runFairness(), and TestData::TestData().

                                   {
  if (a.size() < d.size()) {
    a.resize(d.size());
  }
  for (std::size_t i = 0; i < d.size(); ++i) {
    a[i] += d[i];
  }
}

double folly::f14::expectedProbe

(

std::vector< std::size_t > const &

probeLengths

)

Definition at line 69 of file F14TestUtil.h.

References count, i, and sum().

                                                               {
  std::size_t sum = 0;
  std::size_t count = 0;
  for (std::size_t i = 1; i < probeLengths.size(); ++i) {
    sum += i * probeLengths[i];
    count += probeLengths[i];
  }
  return static_cast<double>(sum) / static_cast<double>(count);
}

void folly::f14::limitTestAllocations ( std::size_t  allocationsBeforeException = 0 )

inline

Definition at line 328 of file F14TestUtil.h.

References testAllocationCount, and testAllocationMaxCount.

Referenced by TEST().

                                                                           {
  testAllocationMaxCount = testAllocationCount + allocationsBeforeException;
}

template<class T1 , class T2 >

bool folly::f14::operator!=	(	SwapTrackingAlloc< T1 > const &	,
		SwapTrackingAlloc< T2 > const &
	)

Definition at line 427 of file F14TestUtil.h.

Referenced by folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), and folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=().

                                                                            {
  return false;
}

std::ostream& folly::f14::operator<<	(	std::ostream &	xo,
		Histo const &	histo
	)

Definition at line 37 of file F14TestUtil.h.

References folly::f14::Histo::data, i, folly::partial(), sum(), and v.

                                                           {
  xo << "[";
  size_t sum = 0;
  for (auto v : histo.data) {
    sum += v;
  }
  size_t partial = 0;
  for (size_t i = 0; i < histo.data.size(); ++i) {
    if (i > 0) {
      xo << ", ";
    }
    partial += histo.data[i];
    if (histo.data[i] > 0) {
      xo << i << ": " << histo.data[i] << " ("
         << (static_cast<double>(partial) * 100.0 / sum) << "%)";
    }
  }
  xo << "]";
  return xo;
}

std::ostream& folly::f14::operator<<	(	std::ostream &	xo,
		Counts const &	counts
	)

Definition at line 173 of file F14TestUtil.h.

References folly::f14::Counts::copyAssign, folly::f14::Counts::copyConstruct, folly::f14::Counts::copyConvert, folly::f14::Counts::defaultConstruct, folly::f14::Counts::destroyed, folly::f14::Counts::moveAssign, folly::f14::Counts::moveConstruct, folly::f14::Counts::moveConvert, and string.

                                                             {
  xo << "[";
  std::string glue = "";
  if (counts.copyConstruct > 0) {
    xo << glue << counts.copyConstruct << " copy";
    glue = ", ";
  }
  if (counts.moveConstruct > 0) {
    xo << glue << counts.moveConstruct << " move";
    glue = ", ";
  }
  if (counts.copyConvert > 0) {
    xo << glue << counts.copyConvert << " copy convert";
    glue = ", ";
  }
  if (counts.moveConvert > 0) {
    xo << glue << counts.moveConvert << " move convert";
    glue = ", ";
  }
  if (counts.copyAssign > 0) {
    xo << glue << counts.copyAssign << " copy assign";
    glue = ", ";
  }
  if (counts.moveAssign > 0) {
    xo << glue << counts.moveAssign << " move assign";
    glue = ", ";
  }
  if (counts.defaultConstruct > 0) {
    xo << glue << counts.defaultConstruct << " default construct";
    glue = ", ";
  }
  if (counts.destroyed > 0) {
    xo << glue << counts.destroyed << " destroyed";
    glue = ", ";
  }
  xo << "]";
  return xo;
}

std::ostream& folly::f14::operator<<	(	std::ostream &	xo,
		F14TableStats const &	stats
	)

Definition at line 431 of file F14TestUtil.h.

References folly::F14TableStats::bucketCount, folly::F14TableStats::chunkCount, folly::F14TableStats::chunkHostedOverflowHisto, folly::F14TableStats::chunkOccupancyHisto, folly::F14TableStats::chunkOutboundOverflowHisto, folly::demangle(), folly::F14TableStats::keyProbeLengthHisto, folly::F14TableStats::missProbeLengthHisto, folly::F14TableStats::overheadBytes, folly::F14TableStats::policy, folly::F14TableStats::size, folly::F14TableStats::totalBytes, and folly::F14TableStats::valueSize.

                                                                   {
  using f14::Histo;

  xo << "{ " << std::endl;
  xo << "  policy: "
#if FOLLY_HAS_RTTI
     << folly::demangle(stats.policy)
#else
     << "unknown (RTTI not availabe)"
#endif
     << std::endl;
  xo << "  size: " << stats.size << std::endl;
  xo << "  valueSize: " << stats.valueSize << std::endl;
  xo << "  bucketCount: " << stats.bucketCount << std::endl;
  xo << "  chunkCount: " << stats.chunkCount << std::endl;
  xo << "  chunkOccupancyHisto" << Histo{stats.chunkOccupancyHisto}
     << std::endl;
  xo << "  chunkOutboundOverflowHisto"
     << Histo{stats.chunkOutboundOverflowHisto} << std::endl;
  xo << "  chunkHostedOverflowHisto" << Histo{stats.chunkHostedOverflowHisto}
     << std::endl;
  xo << "  keyProbeLengthHisto" << Histo{stats.keyProbeLengthHisto}
     << std::endl;
  xo << "  missProbeLengthHisto" << Histo{stats.missProbeLengthHisto}
     << std::endl;
  xo << "  totalBytes: " << stats.totalBytes << std::endl;
  xo << "  valueBytes: " << (stats.size * stats.valueSize) << std::endl;
  xo << "  overheadBytes: " << stats.overheadBytes << std::endl;
  if (stats.size > 0) {
    xo << "  overheadBytesPerKey: "
       << (static_cast<double>(stats.overheadBytes) /
           static_cast<double>(stats.size))
       << std::endl;
  }
  xo << "}";
  return xo;
}

template<class T1 , class T2 >

bool folly::f14::operator==	(	SwapTrackingAlloc< T1 > const &	,
		SwapTrackingAlloc< T2 > const &
	)

Definition at line 422 of file F14TestUtil.h.

Referenced by folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), and folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=().

                                                                            {
  return true;
}

std::size_t folly::f14::p99Probe

(

std::vector< std::size_t > const &

probeLengths

)

Definition at line 81 of file F14TestUtil.h.

References count, i, and suffix.

                                                             {
  std::size_t count = 0;
  for (std::size_t i = 1; i < probeLengths.size(); ++i) {
    count += probeLengths[i];
  }
  std::size_t rv = probeLengths.size();
  std::size_t suffix = 0;
  while ((suffix + probeLengths[rv - 1]) * 100 <= count) {
    --rv;
  }
  return rv;
}

void folly::f14::resetTracking ( )

inline

Definition at line 336 of file F14TestUtil.h.

References max, sumCounts, testAllocatedBlockCount, testAllocatedMemorySize, testAllocationCount, and testAllocationMaxCount.

Referenced by std::hash< TestStruct >::operator()(), TEST(), and testCustomSwap().

                            {
  sumCounts = Counts{};
  Tracked<0>::counts = Counts{};
  Tracked<1>::counts = Counts{};
  Tracked<2>::counts = Counts{};
  Tracked<3>::counts = Counts{};
  Tracked<4>::counts = Counts{};
  Tracked<5>::counts = Counts{};
  testAllocatedMemorySize = 0;
  testAllocatedBlockCount = 0;
  testAllocationCount = 0;
  testAllocationMaxCount = std::numeric_limits<std::size_t>::max();
}

template<class T >

void folly::f14::swap	(	SwapTrackingAlloc< T > &	,
		SwapTrackingAlloc< T > &
	)

Definition at line 414 of file F14TestUtil.h.

Referenced by proxygen::HTTP2PriorityQueue::Node::addChildren(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::any_constrained_single_sender(), folly::pushmi::any_flow_many_sender< PE, PV, E, VN >::any_flow_many_sender(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::any_flow_receiver(), folly::pushmi::any_flow_single_sender< PE, E, VN >::any_flow_single_sender(), folly::pushmi::any_many_sender< E, VN >::any_many_sender(), folly::pushmi::any_receiver< E, folly::pushmi::any_executor_ref< E > >::any_receiver(), folly::pushmi::any_single_sender< E, VN >::any_single_sender(), testing::AssertionResult::AppendMessage(), folly::HHWheelTimer::cancelAll(), folly::StringKeyedMap< Value, Compare, Alloc >::clear(), folly::HazptrSWMRSet< T, Atom >::contains(), folly::ThreadedExecutor::controlJoinFinishedThreads(), folly::ThreadedExecutor::controlLaunchEnqueuedTasks(), proxygen::HTTP2PriorityQueue::Node::emplaceNode(), proxygen::HTTP2PriorityQueue::Node::flattenSubtree(), List< T, Atom >::hand_over_hand(), proxygen::HTTP2PriorityQueue::iterateBFS(), folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), folly::fibers::FiberManager::loopUntilNoReadyImpl(), main(), proxygen::HTTP2PriorityQueue::nextEgress(), proxygen::HPACKHeader::operator=(), folly::fibers::Promise< T, BatonT >::operator=(), folly::SharedPromise< T >::operator=(), folly::DelayedDestructionBase::DestructorGuard::operator=(), folly::ReadMostlyMainPtr< T >::operator=(), folly::SocketAddress::operator=(), folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), folly::ReadMostlyWeakPtr< T >::operator=(), testing::AssertionResult::operator=(), folly::ReadMostlySharedPtr< T >::operator=(), folly::RWSpinLock::ReadHolder::operator=(), folly::ThreadLocalPtr< T, Tag, AccessMode >::Accessor::operator=(), folly::RWSpinLock::UpgradedHolder::operator=(), folly::RWSpinLock::WriteHolder::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::ReadHolder::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::UpgradeHolder::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WriteHolder::operator=(), folly::symbolizer::Dwarf::Path::Path(), folly::observer_detail::ObserverManager::DependencyRecorder::release(), folly::observer_detail::Core::removeStaleDependents(), folly::threadlocal_detail::StaticMetaBase::reserve(), folly::threadlocal_detail::StaticMetaBase::reserveHeadUnlocked(), run_queue_moving(), wangle::OutputBufferingHandler::runLoopCallback(), runMultiScopeTest(), folly::RequestContext::setShallowCopyContext(), testing::internal::ShouldRunTestCase(), folly::test::UniformSubset::shufflePrefix(), testing::internal::ShuffleRange(), proxygen::compress::SimStreamingCallback::SimStreamingCallback(), folly::coro::detail::ViaCoroutine::swap(), folly::StringKeyedSetBase< Compare, Alloc >::swap(), folly::coro::TaskWithExecutor< T >::swap(), folly::coro::Task< T >::swap(), testing::AssertionResult::swap(), folly::RWSpinLock::ReadHolder::swap(), folly::RWSpinLock::UpgradedHolder::swap(), folly::padded::Adaptor< IntNodeVec >::swap(), folly::RWSpinLock::WriteHolder::swap(), folly::Replaceable< T >::swap(), swap_test(), TEST(), folly::TEST(), TEST_F(), test_nonmemberSwappable3(), testCustomSwap(), testRandom(), proxygen::DanglingQueueTestBase::tick(), u64ToAsciiClassic(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                        {
  // For argument dependent lookup:
  // This function will be called if the custom swap functions of F14 containers
  // are used. Otherwise, std::swap() will do 1 move construct and 2 move
  // assigns which will get tracked by t_.
}

void folly::f14::unlimitTestAllocations ( )

inline

Definition at line 332 of file F14TestUtil.h.

References max, and testAllocationMaxCount.

Referenced by TEST().

                                     {
  testAllocationMaxCount = std::numeric_limits<std::size_t>::max();
}

Variable Documentation

thread_local Counts folly::f14::sumCounts {}

Definition at line 212 of file F14TestUtil.h.

Referenced by folly::f14::Tracked< 0 >::operator=(), resetTracking(), folly::f14::Tracked< 0 >::Tracked(), and folly::f14::Tracked< 0 >::~Tracked().

thread_local size_t folly::f14::testAllocatedBlockCount {0}

Definition at line 323 of file F14TestUtil.h.

Referenced by folly::f14::SwapTrackingAlloc< T >::allocate(), folly::f14::SwapTrackingAlloc< T >::deallocate(), resetTracking(), and TEST().

thread_local size_t folly::f14::testAllocatedMemorySize {0}

Definition at line 322 of file F14TestUtil.h.

Referenced by folly::f14::SwapTrackingAlloc< T >::allocate(), folly::f14::SwapTrackingAlloc< T >::deallocate(), resetTracking(), and TEST().

thread_local size_t folly::f14::testAllocationCount {0}

Definition at line 324 of file F14TestUtil.h.

Referenced by folly::f14::SwapTrackingAlloc< T >::allocate(), limitTestAllocations(), and resetTracking().

thread_local size_t folly::f14::testAllocationMaxCount

Initial value:

{
    std::numeric_limits<std::size_t>::max()}

Definition at line 325 of file F14TestUtil.h.

Referenced by folly::f14::SwapTrackingAlloc< T >::allocate(), limitTestAllocations(), resetTracking(), and unlimitTestAllocations().