CxxUtils Namespace Reference

Namespaces
	detail
	fpcompare
	fpcompare_fn
	vecDetail

Classes
class	Array
	Read-only multidimensional array. More...
class	Array< 0 >
	Read-only multidimensional array, specialized for N=0. More...
class	ArrayIterator
	Iterator class for Array<N>. More...
class	ArrayIteratorChooser
	Helper for defining iterators over Array's. More...
class	ArrayIteratorChooser< 1 >
	Helper for defining iterators over Array's, specialized for N == 1. More...
class	ArrayScanner
	Helper class for converting strings to Array's. More...
class	BitPacker
	Pack a set of values bitwise into a stream. More...
class	BitPacker16
	Pack a set of values bitwise into a stream. More...
class	BitPacker8
	Pack a set of values bitwise into a stream. More...
class	BitUnpacker
	Helper to unpack a set of values bitwise from a stream. More...
class	BitUnpacker16
	Helper to unpack a set of values bitwise from a stream. More...
class	BitUnpacker8
	Helper to unpack a set of values bitwise from a stream. More...
union	CachedPointer
	Cached pointer with atomic update. More...
class	CachedUniquePtrT
	Cached pointer with atomic update. More...
class	CachedValue
	Cached value with atomic update. More...
class	ClassName
	Recursively separate out template arguments in a C++ class name. More...
class	CMurmurHash2A
class	ConcurrentBitset
	Variable-sized bitset allowing (mostly) concurrent access. More...
class	CRCTable
	Precomputed tables and constants for the CRC calculation. More...
struct	extrace_init
class	FloatCompressor
	Class implementing a lossy float compression. More...
class	FloatPacker
	Pack/unpack floating-point data from/to a given number of bits. More...
class	IRangeMapPayloadDeleter
	Helper to delete payload objects for ConcurrentRangeMap. More...
class	LockedPointer
	A pointer together with a movable lock. More...
class	PackedArray
	An array of unsigned values of some bit size, packed tightly. More...
class	pointer_list
	A fast way to store a variable-sized collection of pointers. More...
class	pointer_list_base
	A fast way to store a variable-sized collection of pointers. More...
class	range_with_at
	Add at() methods to a range class. More...
class	range_with_conv
	Add to a range class conversions to containers. More...
class	RedirStderr
class	releasing_iterator
	Adapter to retrieve elements from a unique_ptr iterator via release(). More...
class	reverse_wrapper
	Adapter for a container-like class to be used in a range-for so as to iterate in the reverse direction. More...
class	Ring
	A very simple ring buffer. More...
class	SimpleUpdater
	Simple (non-deleting) Updater implementation. More...
struct	sincos
	Helper to simultaneously calculate sin and cos of the same angle. More...
class	span
	Simplified version of the C++20 std::span. More...
struct	vec_fb
class	WritableArray
	Read-write multidimensional array. More...
class	WritableArray< 0 >
class	WritableArrayData

Typedefs
template<class T , size_t Alignment = 1>
using	aligned_vector = std::vector< T, boost::alignment::aligned_allocator< T, Alignment > >
	A std::vector with extra alignment. More...
template<class T >
using	vec_aligned_vector = aligned_vector< T, 64 >
	A std::vector with alignment sufficient for any vector instructions on this platform. More...
template<class T >
using	CachedUniquePtr = CachedUniquePtrT< const T >
template<std::ranges::input_range SPAN, class XFORM >
using	transform_view_with_at = range_with_at< std::ranges::transform_view< SPAN, XFORM > >
	Helper to add at() methods to a transform_view. More...
template<typename T , size_t N>
using	vec = typename vecDetail::vec_typedef< T, N >::type
	Define a nice alias for the vectorized type. More...
template<class VEC >
using	vec_type_t = typename vecDetail::vec_type< VEC >::type
	Define a nice alias for the element type of a vectorized type. More...
template<class VEC >
using	vec_mask_type_t = typename vecDetail::vec_mask_type< VEC >::type
	Define a nice alias for the mask type for a vectorized type. More...
template<typename T , size_t N>
using	ivec = vec_fb< typename boost::int_t< sizeof(T) *8 >::exact, N >

Enumerations
enum	CacheState : unsigned char { INVALID = 0, UPDATING = 1, VALID = 2 }
	State of the cached value; see below. More...
enum	{ CacheLineSize = 64 }
	While it is possible to determine cache line size at run time (e.g. More...

Functions
template<unsigned int N>
std::ostream &	operator<< (std::ostream &s, const Array< N > &a)
template<class T >
requires std::assignable_from< T &, float > void	fromArrayrep (const CaloRec::Arrayrep &rep, T &x)
	Helper to convert from an @x Arrayrep to a scalar type. More...
template<unsigned int N>
void	fromArrayrep (const CaloRec::Arrayrep &rep, CxxUtils::Array< N > &x)
	Helper to convert from an @x Arrayrep to an Array. More...
template<class T >
const T *	as_const_ptr (const T *p)
	Helper for getting a const version of a pointer. More...
template<class T >
T	atomic_bounded_decrement (std::atomic< T > *a, T bound=0, T decr=1, std::memory_order memorder=std::memory_order_seq_cst)
	Atomically decrement a value with a lower bound. More...
template<class T >
T	atomic_fetch_max (std::atomic< T > *a, T v, std::memory_order memorder=std::memory_order_seq_cst)
	Atomically calculate maximum. More...
template<class T >
T	atomic_fetch_min (std::atomic< T > *a, T v, std::memory_order memorder=std::memory_order_seq_cst)
	Atomically calculate minimum. More...
std::string	base64_encode (const unsigned char *, unsigned int)
std::vector< unsigned char >	base64_decode (const std::string &)
template<class E >
constexpr std::enable_if_t< is_bitmask_v< E >, E & >	set (E &lhs, E rhs)
	Convenience function to set bits in a class enum bitmask. More...
template<class E >
constexpr std::enable_if_t< is_bitmask_v< E >, E & >	reset (E &lhs, E rhs)
	Convenience function to clear bits in a class enum bitmask. More...
template<class E >
constexpr std::enable_if_t< is_bitmask_v< E >, bool >	test (E lhs, E rhs)
	Convenience function to test bits in a class enum bitmask. More...
template<class KEY , class VALUE , template< class > class UPDATER, class HASHER = std::hash<KEY>, class MATCHER = std::equal_to<KEY>, detail::ConcurrentHashmapVal_t NULLVAL = 0, detail::ConcurrentHashmapVal_t TOMBSTONE = NULLVAL>
	requires (detail::IsConcurrentHashmapPayload< KEY > &&detail::IsConcurrentHashmapPayload< VALUE > &&detail::IsUpdater< UPDATER > &&detail::IsHash< HASHER, KEY > &&detail::IsBinaryPredicate< MATCHER, KEY >) class ConcurrentMap
	Hash map from integers/pointers allowing concurrent, lockless reads. More...
template<class VALUE , template< class > class UPDATER>
	requires (detail::IsUpdater< UPDATER >) class ConcurrentPtrSet
	A set of pointers, allowing concurrent, lockless queries. More...
template<class RANGE , class KEY , class T , class COMPARE , template< class > class UPDATER>
	requires (detail::IsUpdater< UPDATER > &&detail::IsConcurrentRangeCompare< COMPARE, RANGE, KEY, typename UPDATER< int >::Context_t >) class ConcurrentRangeMap
	Map from range to payload object, allowing concurrent, lockless reads. More...
template<class VALUE , template< class > class UPDATER>
	requires (detail::IsConcurrentHashmapPayload< VALUE > &&detail::IsUpdater< UPDATER >) class ConcurrentStrMap
	Hash map from strings allowing concurrent, lockless reads. More...
template<class KEY , class VALUE , template< class > class UPDATER, class HASHER = std::hash<KEY>, class MATCHER = std::equal_to<KEY>, detail::ConcurrentHashmapVal_t NULLVAL = 0>
	requires (detail::IsConcurrentHashmapPayload< KEY > &&detail::IsUpdater< UPDATER > &&detail::IsHash< HASHER, KEY > &&detail::IsBinaryPredicate< MATCHER, KEY >) class ConcurrentToValMap
	Hash map from pointers/integers to arbitrary objects allowing concurrent, lockless reads. More...
template<class InputIterator , class OutputIterator , class InputTag , class OutputTag >
OutputIterator	copy_bounded1 (InputIterator begi, InputIterator endi, OutputIterator bego, OutputIterator endo, const InputTag &, const OutputTag &)
	Copy a range with bounds restriction; generic version. More...
template<class InputIterator , class OutputIterator >
OutputIterator	copy_bounded1 (InputIterator begi, InputIterator endi, OutputIterator bego, OutputIterator endo, const std::random_access_iterator_tag &, const std::random_access_iterator_tag &)
	Copy a range with bounds restriction; random_access_iterator version. More...
template<std::input_iterator InputIterator, std::output_iterator< typename std::iterator_traits< InputIterator >::value_type > OutputIterator>
OutputIterator	copy_bounded (InputIterator begi, InputIterator endi, OutputIterator bego, OutputIterator endo)
	Copy a range with bounds restriction. More...
template<class InputRange , class OutputRange >
auto	copy_bounded (const InputRange &input, OutputRange &output) -> decltype(std::begin(output))
	Copy a range with bounds restriction. More...
template<class InputRange , class OutputRange >
auto	copy_bounded (const InputRange &input, OutputRange &&output) -> decltype(std::begin(output))
	Copy a range with bounds restriction. More...
void	deleteCRCTable (CxxUtils::CRCTable *table)
	Delete a CRCTable object. More...
std::unique_ptr< CRCTable >	makeCRCTable (uint64_t p, uint64_t initial=0xffffffffffffffff)
	Initialize CRC tables and constants. More...
uint64_t	crc64_bytewise (const CRCTable &table, const char *data, size_t data_len)
	Find the CRC-64 of a string, using a byte-by-byte algorithm. More...
uint64_t	crc64_bytewise (const char *data, size_t data_len)
	Find the CRC-64 of a string, using a byte-by-byte algorithm, with the default CRC. More...
uint64_t	crc64_bytewise (const std::string &s)
	Find the CRC-64 of a string, using a byte-by-byte algorithm, with the default CRC. More...
uint64_t	crc64 (const CRCTable &table, const char *data, size_t data_len)
	Find the CRC-64 of a string,. More...
uint64_t	crc64 (const char *data, size_t data_len)
	Find the CRC-64 of a string, with the default CRC. More...
uint64_t	crc64 (const std::string &s)
	Find the CRC-64 of a string, using the default polynomial. More...
uint64_t	crc64addint (uint64_t crc, uint64_t x)
	Extend a previously-calculated CRC to include an int. More...
std::string	crc64format (uint64_t crc)
	Format a CRC-64 as a string. More...
std::string	crc64digest (const std::string &str)
	Return a CRC-64 digest of a string. More...
void	exctrace (const std::exception &e, IOFD fd=IOFD_INVALID)
	Print out information for the last exception. More...
uint16_t	le16toh (uint16_t x)
uint32_t	le32toh (uint32_t x)
uint64_t	le64toh (uint64_t x)
uint16_t	get_unaligned16 (const uint8_t *ATH_RESTRICT &p)
	Read a 2-byte little-endian value from a possibly unaligned pointer. More...
uint32_t	get_unaligned32 (const uint8_t *ATH_RESTRICT &p)
	Read a 4-byte little-endian value from a possibly unaligned pointer. More...
uint64_t	get_unaligned64 (const uint8_t *ATH_RESTRICT &p)
	Read an 8-byte little-endian value from a possibly unaligned pointer. More...
float	get_unaligned_float (const uint8_t *ATH_RESTRICT &p)
	Read a little-endian float value from a possibly unaligned pointer. More...
double	get_unaligned_double (const uint8_t *ATH_RESTRICT &p)
	Read a little-endian double value from a possibly unaligned pointer. More...
template<class T >
T	get_unaligned (const uint8_t *ATH_RESTRICT &p)
	Define templated versions of the above functions. More...
template<>
uint8_t	get_unaligned< uint8_t > (const uint8_t *ATH_RESTRICT &p)
template<>
uint16_t	get_unaligned< uint16_t > (const uint8_t *ATH_RESTRICT &p)
template<>
uint32_t	get_unaligned< uint32_t > (const uint8_t *ATH_RESTRICT &p)
template<>
uint64_t	get_unaligned< uint64_t > (const uint8_t *ATH_RESTRICT &p)
template<>
float	get_unaligned< float > (const uint8_t *ATH_RESTRICT &p)
template<>
double	get_unaligned< double > (const uint8_t *ATH_RESTRICT &p)
template<>
int8_t	get_unaligned< int8_t > (const uint8_t *ATH_RESTRICT &p)
template<>
int16_t	get_unaligned< int16_t > (const uint8_t *ATH_RESTRICT &p)
template<>
int32_t	get_unaligned< int32_t > (const uint8_t *ATH_RESTRICT &p)
template<>
int64_t	get_unaligned< int64_t > (const uint8_t *ATH_RESTRICT &p)
void	hexdump (std::ostream &s, const void *addr, size_t n, size_t offset=0)
	Make a hex dump of memory. More...
void	safeHexdump (std::ostream &s, const void *addr, size_t n, size_t offset=0)
	Make a hex dump of memory, protected against bad reads. More...
template<class RANGE , class FUNC >
auto	min_transformed_element (RANGE &&r, FUNC &&f)
	Find the minimum transformed element in a range. More...
template<class RANGE , class FUNC >
auto	max_transformed_element (RANGE &&r, FUNC &&f)
	Find the maximum transformed element in a range. More...
uint32_t	MurmurHash2 (const void *key, int len, uint32_t seed)
uint64_t	MurmurHash64A (const void *key, int len, uint64_t seed)
uint64_t	MurmurHash64B (const void *key, int len, uint64_t seed)
uint32_t	MurmurHash2A (const void *key, int len, uint32_t seed)
uint32_t	MurmurHashNeutral2 (const void *key, int len, uint32_t seed)
uint32_t	MurmurHashAligned2 (const void *key, int len, uint32_t seed)
std::string	normalizeFunctionName (const std::string &fname)
	Normalize a pretty-printed C++ function name. More...
template<class T >
constexpr T	ones (unsigned int n)
	Return a bit mask with the lower n bits set. More...
template<typename T >
T	wrapToPi (T phi)
	Wrap angle in radians to [-pi, pi]. More...
template<typename T >
T	deltaPhi (T phiA, T phiB)
	Return difference phiA - phiB in range [-pi, pi]. More...
template<typename T >
T	phiMean (T phiA, T phiB)
	Calculate average of two angles. More...
template<typename T >
T	phiBisect (T phiA, T phiB)
	Bisect (average) the angle spanned by phiA and phiB. More...
void	prefetchOne (const void *address)
	Generic prefetch method. More...
template<size_t N>
void	prefetchN (const void *ptr)
	Prefetch an N-byte block of memory. More...
template<typename T >
void	prefetchObj (const T *ptr)
	Generic prefetch of the object of specific types (sizes). More...
template<typename Iter >
void	prefetchNext (Iter iter, Iter endIter)
	Prefetch next object in sequence. More...
template<typename Iter >
void	prefetchTwo (Iter iter, Iter endIter)
	Prefetch two objects. More...
template<class T >
auto	begin (range_with_at< T > &s)
template<class T >
auto	begin (const range_with_at< T > &s)
template<class T >
auto	end (range_with_at< T > &s)
template<class T >
auto	end (const range_with_at< T > &s)
template<class T >
auto	begin (range_with_conv< T > &s)
template<class T >
auto	begin (const range_with_conv< T > &s)
template<class T >
auto	end (range_with_conv< T > &s)
template<class T >
auto	end (const range_with_conv< T > &s)
template<class CONT , class RANGE >
CONT	to (RANGE &&r)
template<class T >
auto	make_reverse_wrapper (T &r)
	Make a reverse_wrapper for a given container-like object. More...
uint16_t	htole16 (uint16_t x)
uint32_t	htole32 (uint32_t x)
uint64_t	htole64 (uint64_t x)
void	set_unaligned16 (uint8_t *ATH_RESTRICT &p, uint16_t val)
	Write a 2-byte little-endian value to a possibly unaligned pointer. More...
void	set_unaligned32 (uint8_t *ATH_RESTRICT &p, uint32_t val)
	Write a 4-byte little-endian value to a possibly unaligned pointer. More...
void	set_unaligned64 (uint8_t *ATH_RESTRICT &p, uint64_t val)
	Write an 8-byte little-endian value to a possibly unaligned pointer. More...
void	set_unaligned_float (uint8_t *ATH_RESTRICT &p, float val)
	Write a little-endian float value to a possibly unaligned pointer. More...
void	set_unaligned_double (uint8_t *ATH_RESTRICT &p, double val)
	Write a little-endian double value to a possibly unaligned pointer. More...
template<class T >
void	set_unaligned (uint8_t *ATH_RESTRICT &p, T val)
	Define templated versions of the above functions. More...
template<>
void	set_unaligned< uint8_t > (uint8_t *ATH_RESTRICT &p, uint8_t val)
template<>
void	set_unaligned< uint16_t > (uint8_t *ATH_RESTRICT &p, uint16_t val)
template<>
void	set_unaligned< uint32_t > (uint8_t *ATH_RESTRICT &p, uint32_t val)
template<>
void	set_unaligned< uint64_t > (uint8_t *ATH_RESTRICT &p, uint64_t val)
template<>
void	set_unaligned< float > (uint8_t *ATH_RESTRICT &p, float f)
template<>
void	set_unaligned< double > (uint8_t *ATH_RESTRICT &p, double f)
template<>
void	set_unaligned< int8_t > (uint8_t *ATH_RESTRICT &p, int8_t val)
template<>
void	set_unaligned< int16_t > (uint8_t *ATH_RESTRICT &p, int16_t val)
template<>
void	set_unaligned< int32_t > (uint8_t *ATH_RESTRICT &p, int32_t val)
template<>
void	set_unaligned< int64_t > (uint8_t *ATH_RESTRICT &p, int64_t val)
template<class T >
	span (T *ptr, std::size_t sz) -> span< T >
	A couple needed deduction guides. More...
template<class T >
	span (T *beg, T *end) -> span< T >
template<detail::IsContiguousContainer CONTAINER>
auto	make_span (CONTAINER &c)
	Helper to make a span from a container. More...
template<class T >
auto	begin (span< T > &s)
template<class T >
auto	begin (const span< T > &s)
template<class T >
auto	end (span< T > &s)
template<class T >
auto	end (const span< T > &s)
void	stall ()
	Emit stall instruction for use in a spin loop. More...
std::string	strformat (const char *fmt,...)
	return a std::string according to a format fmt and varargs More...
int	atoi (std::string_view str)
	Helper functions to unpack numbers decoded in string into integers and doubles The strings are required to contain only digits, a floating point dot, the signs +- or a whitespace Exceptions are thrown otherwise. More...
double	atof (std::string_view str)
	Converts a string into a double / float. More...
std::string_view	eraseWhiteSpaces (std::string_view str)
	Removes all trailing and starting whitespaces from a string. More...
std::vector< std::string >	tokenize (const std::string &the_str, std::string_view delimiters)
	Splits the string into smaller substrings. More...
std::vector< double >	tokenizeDouble (const std::string &the_str, std::string_view delimiter)
std::vector< int >	tokenizeInt (const std::string &the_str, std::string_view delimiter)
void	ubsan_suppress (void(*func)())
	Helper for suppressing ubsan warnings. More...
template<class VEC >
constexpr ATH_ALWAYS_INLINE size_t	vec_size ()
	Return the number of elements in a vectorized type. More...
template<class VEC >
constexpr ATH_ALWAYS_INLINE size_t	vec_size (const VEC &)
	Return the number of elements in a vectorized type. More...
template<typename VEC , typename T >
ATH_ALWAYS_INLINE void	vbroadcast (VEC &v, T x)
	Copy a scalar to each element of a vectorized type. More...
template<typename VEC >
ATH_ALWAYS_INLINE void	vload (VEC &dst, vec_type_t< VEC > const *src)
template<typename VEC >
ATH_ALWAYS_INLINE void	vstore (vec_type_t< VEC > *dst, const VEC &src)
template<typename VEC >
ATH_ALWAYS_INLINE void	vselect (VEC &dst, const VEC &a, const VEC &b, const vec_mask_type_t< VEC > &mask)
template<typename VEC >
ATH_ALWAYS_INLINE void	vmin (VEC &dst, const VEC &a, const VEC &b)
template<typename VEC >
ATH_ALWAYS_INLINE void	vmax (VEC &dst, const VEC &a, const VEC &b)
template<typename VEC >
ATH_ALWAYS_INLINE bool	vany (const VEC &mask)
template<typename VEC >
ATH_ALWAYS_INLINE bool	vnone (const VEC &mask)
template<typename VEC >
ATH_ALWAYS_INLINE bool	vall (const VEC &mask)
template<typename VEC1 , typename VEC2 >
ATH_ALWAYS_INLINE void	vconvert (VEC1 &dst, const VEC2 &src)
	performs dst is the result of a static cast of each element of src More...
template<size_t... Indices, typename VEC , typename VEC1 >
ATH_ALWAYS_INLINE void	vpermute (VEC1 &dst, const VEC &src)
	vpermute function. More...
template<size_t... Indices, typename VEC , typename VEC1 >
ATH_ALWAYS_INLINE void	vpermute2 (VEC1 &dst, const VEC &src1, const VEC &src2)
	vpermute2 function. More...
template<typename T , size_t N>
ivec< T, N >	operator! (const vec_fb< T, N > &a)
	Negation. More...
template<typename T , size_t N>
ivec< T, N >	operator&& (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 && V2. More...
template<typename T , size_t N, class U >
ivec< T, N >	operator&& (U a, const vec_fb< T, N > &b)
	S && V. More...
template<typename T , size_t N, class U >
ivec< T, N >	operator&& (const vec_fb< T, N > &a, U b)
	V && S. More...
template<typename T , size_t N>
ivec< T, N >	operator|| (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 || V2. More...
std::string	clean_allocator (std::string f)
	Clean ‘allocator’ template arguments from the function f. More...
std::string	munge_string_name (const std::string &str_in)
std::string	munge_punct (const std::string &str_in)
std::string	do_replace (std::string s, const std::string &pat, const std::string &rep)
std::string	munge_names (const std::string &str_in)
template<class dType >
void	convertToNumber (std::string_view str, dType &number)

Variables
template<class T >
concept	FromArrayrep
	Concept testing whether a type may be used with FromArrayrep. More...
template<class RANGE , class T >
concept	InputRangeOverT
	Concept for an input range over a given type. More...
constexpr size_t	dynamic_extent = static_cast<size_t>(-1)
	Used to specify a subrange of indefinite size in subspan(). More...
template<class T , class U >
constexpr bool	valid_span_type_v = std::is_convertible_v<U(*)[], T(*)[]>
	Is U* a valid type to use to initialize a span<T>? No more than const-conversion. More...
const CRCTable	defaultCRCTable (0xad93d23594c935a9)

Typedef Documentation

aligned_vector

template<class T , size_t Alignment = 1>

using CxxUtils::aligned_vector = typedef std::vector<T, boost::alignment::aligned_allocator<T, Alignment> >

A std::vector with extra alignment.

The alignment for the payload will be at least either that required by T or Alignment, whichever is greater.

Definition at line 39 of file aligned_vector.h.

CachedUniquePtr

template<class T >

using CxxUtils::CachedUniquePtr = typedef CachedUniquePtrT<const T>

Definition at line 114 of file CachedUniquePtr.h.

ivec

template<typename T , size_t N>

using CxxUtils::ivec = typedef vec_fb<typename boost::int_t<sizeof(T) * 8>::exact, N>

Definition at line 53 of file vec_fb.h.

transform_view_with_at

template<std::ranges::input_range SPAN, class XFORM >

using CxxUtils::transform_view_with_at = typedef range_with_at<std::ranges::transform_view<SPAN, XFORM> >

Helper to add at() methods to a transform_view.

Definition at line 57 of file range_with_at.h.

vec

template<typename T , size_t N>

using CxxUtils::vec = typedef typename vecDetail::vec_typedef<T,N>::type

Define a nice alias for the vectorized type.

Definition at line 207 of file vec.h.

vec_aligned_vector

template<class T >

using CxxUtils::vec_aligned_vector = typedef aligned_vector<T, 64>

A std::vector with alignment sufficient for any vector instructions on this platform.

For now, just hard code 64, which is sufficient for a 512-bit vector, the largest supported by any x86 processors. We may want to make this platform-dependent in the future.

Definition at line 51 of file aligned_vector.h.

vec_mask_type_t

template<class VEC >

using CxxUtils::vec_mask_type_t = typedef typename vecDetail::vec_mask_type<VEC>::type

Define a nice alias for the mask type for a vectorized type.

Definition at line 219 of file vec.h.

vec_type_t

template<class VEC >

using CxxUtils::vec_type_t = typedef typename vecDetail::vec_type<VEC>::type

Define a nice alias for the element type of a vectorized type.

Definition at line 213 of file vec.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

While it is possible to determine cache line size at run time (e.g.

using sysconf(_SC_LEVEL1_DCACHE_LINESIZE) on Linux or sysctlbyname("hw.cachelinesize", ...) on Apple systems) that approach creates more problems: the location that stores cache line size will probably be out of cache when one needs to know it. This is why we use a compile time constant for cache line size. Cache line size is 64 for the current generation of Intel/AMD CPUs.

If an object spans multiple cache lines then prefetching whole object should be done by prefetching at least one address from each of the cache lines that object occupies. How many lines are needed depends on three things: object size, cache line size, and object starting address. If CacheLineSize is lower than the actual line size then more prefetches than necessary will be generated (2, 4, or more per cache line if cache line size is power of 2). This may be somewhat wasteful so this number may need to be adjusted in the far future when all CPUs have wider cache lines.

Enumerator
CacheLineSize

Definition at line 59 of file prefetch.h.

{ CacheLineSize = 64 };

CacheState

enum CxxUtils::CacheState : unsigned char

State of the cached value; see below.

Enumerator
INVALID
UPDATING
VALID

Definition at line 27 of file CachedValue.h.

                : unsigned char {
  INVALID = 0,
  UPDATING = 1,
  VALID = 2
};

Function Documentation

as_const_ptr()

template<class T >

const T* CxxUtils::as_const_ptr ( const T *  p )

inline

Helper for getting a const version of a pointer.

Parameters

p	Pointer to convert.

Given T* p, as_const_ptr(p) will return p as a const T*.

This is similar in spirit to std::as_const (which doesn't really do what you might expect for pointers).

Definition at line 32 of file as_const_ptr.h.

{
  return p;
}

atof()

double CxxUtils::atof

(

std::string_view

str

)

Converts a string into a double / float.

Definition at line 91 of file Control/CxxUtils/Root/StringUtils.cxx.

                                    {       
        double result{std::numeric_limits<double>::max()};
        convertToNumber(str, result);
        return result;
    }

atoi()

int CxxUtils::atoi

(

std::string_view

str

)

Helper functions to unpack numbers decoded in string into integers and doubles The strings are required to contain only digits, a floating point dot, the signs +- or a whitespace Exceptions are thrown otherwise.

Converts a string into an integer

Definition at line 85 of file Control/CxxUtils/Root/StringUtils.cxx.

                                 { 
        int result{std::numeric_limits<int>::max()};
       convertToNumber(str, result);       
        return result;
    }

atomic_bounded_decrement()

template<class T >

T CxxUtils::atomic_bounded_decrement ( std::atomic< T > *  a, T  bound = 0, T  decr = 1, std::memory_order  memorder = std::memory_order_seq_cst  )

inline

Atomically decrement a value with a lower bound.

Parameters

a	Pointer to the atomic value.
bound	Lower bound for a.
decr	The amount by which to decrement.
memorder	Memory ordering.

Atomically decrement A by DECR, provided the result is not less than BOUND. I.e., the atomic equivalent of:

if (a >= bound + decr) a -= decr;

Returns in any case the original value of the atomic variable.

Definition at line 41 of file atomic_bounded_decrement.h.

{
  T orig = a->load (memorder);
  // Be careful with the comparison here --- it needs to work for
  // unsigned values, so we don't want to subtract decr from orig.
  while (orig >= bound + decr &&
         !a->compare_exchange_strong (orig, orig - decr, memorder)) {
    CxxUtils::stall();
  }
  return orig;
}

atomic_fetch_max()

template<class T >

T CxxUtils::atomic_fetch_max ( std::atomic< T > *  a, T  v, std::memory_order  memorder = std::memory_order_seq_cst  )

inline

Atomically calculate maximum.

Parameters

a	Pointer to the atomic value.
v	The other value.
memorder	Memory ordering.

Computes max(*a, v) and stores it in *a. Returns the original value of *a.

Definition at line 42 of file atomic_fetch_minmax.h.

{
  T orig = a->load (memorder);
  while (v > orig && !a->compare_exchange_strong (orig, v, memorder)) {
    CxxUtils::stall();
  }
  return orig;
}

atomic_fetch_min()

template<class T >

T CxxUtils::atomic_fetch_min ( std::atomic< T > *  a, T  v, std::memory_order  memorder = std::memory_order_seq_cst  )

inline

Atomically calculate minimum.

Parameters

a	Pointer to the atomic value.
v	The other value.
memorder	Memory ordering.

Computes min(*a, v) and stores it in *a. Returns the original value of *a.

Definition at line 63 of file atomic_fetch_minmax.h.

{
  T orig = a->load (memorder);
  while (v < orig && !a->compare_exchange_strong (orig, v, memorder)) {
    CxxUtils::stall();
  }
  return orig;
}

base64_decode()

std::vector< unsigned char > CxxUtils::base64_decode

(

const std::string &

encoded_string

)

Definition at line 97 of file base64.cxx.

                                                                        {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::vector<unsigned char> ret;
 
  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = base64_chars.find(char_array_4[i]);
 
      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
      for (i = 0; (i < 3); i++)
          ret.push_back(char_array_3[i]);
      i = 0;
    }
  }
 
  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;
 
    for (j = 0; j <4; j++)
      char_array_4[j] = base64_chars.find(char_array_4[j]);
 
    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
    for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]);
  }
 
  return ret;
}

base64_encode()

std::string CxxUtils::base64_encode	(	const unsigned char *	bytes_to_encode,
		unsigned int	in_len
	)

Definition at line 55 of file base64.cxx.

                                                                                   {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];
 
  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;
 
      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }
 
  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';
 
    char_array_4[0] = ( char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 
    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];
 
    while((i++ < 3))
      ret += '=';
 
  }
 
  return ret;
 
}

begin() [1/6]

template<class T >

auto CxxUtils::begin

(

const range_with_at< T > &

s

)

Definition at line 66 of file range_with_at.h.

{ return s.begin(); }

begin() [2/6]

template<class T >

auto CxxUtils::begin

(

const range_with_conv< T > &

s

)

Definition at line 61 of file range_with_conv.h.

{ return s.begin(); }

begin() [3/6]

template<class T >

auto CxxUtils::begin

(

const span< T > &

s

)

Definition at line 330 of file span.h.

{ return s.begin(); }

begin() [4/6]

template<class T >

auto CxxUtils::begin

(

range_with_at< T > &

s

)

Definition at line 64 of file range_with_at.h.

{ return s.begin(); }

begin() [5/6]

template<class T >

auto CxxUtils::begin

(

range_with_conv< T > &

s

)

Definition at line 59 of file range_with_conv.h.

{ return s.begin(); }

begin() [6/6]

template<class T >

auto CxxUtils::begin

(

span< T > &

s

)

Definition at line 328 of file span.h.

{ return s.begin(); }

clean_allocator()

std::string CxxUtils::clean_allocator

(

std::string

f

)

Clean ‘allocator’ template arguments from the function f.

Parameters

f	Name of the function to clean.

Definition at line 24 of file normalizeFunctionName.cxx.

{
  std::string::size_type ipos = 0;
  while ((ipos = f.find (", std::allocator", ipos)) != std::string::npos) {
    const char* p = f.c_str() + ipos + 16;
    while (isspace (*p)) ++p;
    if (*p == '<') {
      ++p;
      int nest = 1;
      while (nest > 0 && *p) {
        if (*p == '<')
          ++nest;
        else if (*p == '>')
          --nest;
        ++p;
      }
      if (nest == 0) {
        if (ipos > 0 && f[ipos-1] != '>') {
          while (isspace (*p)) ++p;
        }
        f.erase (ipos, p-f.c_str()-ipos);
        p = f.c_str() + ipos;
      }
    }
    ipos = p - f.c_str();
  }
  return f;
}

convertToNumber()

template<class dType >

void CxxUtils::convertToNumber	(	std::string_view	str,
		dType &	number
	)

Allow for trailing & leading white spaces

To avoid infinite recursion because of string like '42 24' check that white spaces have been indeed removed

Definition at line 65 of file Control/CxxUtils/Root/StringUtils.cxx.

                                                                                   {
        if (str.empty()) {
            number = 0;
            return;   
        }
        if (std::find_if(str.begin(), str.end(), [](const char c){ return std::isspace(c);}) != str.end()) {
            std::string_view spaceFreeStr = eraseWhiteSpaces(str);
            if (spaceFreeStr.size() != str.size()) {
                convertToNumber(spaceFreeStr, number);
                return;
            }
        }
        if (std::from_chars(str.data(), str.data() + str.size(), number).ec !=  std::errc{}) {
            std::stringstream err_except{};
            err_except<<"CxxUtils::convertToNumber() - The string '"<<str<<"'. Contains unallowed chars";
            throw std::runtime_error(err_except.str());
        }
    }

copy_bounded() [1/3]

template<class InputRange , class OutputRange >

auto CxxUtils::copy_bounded ( const InputRange &  input, OutputRange &&  output  ) -> decltype (std::begin(output))

inline

Copy a range with bounds restriction.

Parameters

input	Input range
output	Output range

copy_bounded written in terms of iterator ranges.

We have this as a distinct overload in order to be able to pass a CxxUtils::span temporary as the second argument.

Definition at line 121 of file copy_bounded.h.

{
  return copy_bounded
    (std::begin(input),  std::end(input),
     std::begin(output), std::end(output));
}

copy_bounded() [2/3]

template<class InputRange , class OutputRange >

auto CxxUtils::copy_bounded ( const InputRange &  input, OutputRange &  output  ) -> decltype (std::begin(output))

inline

Copy a range with bounds restriction.

Parameters

input	Input range
output	Output range

copy_bounded written in terms of iterator ranges.

Definition at line 99 of file copy_bounded.h.

{
  return copy_bounded
    (std::begin(input),  std::end(input),
     std::begin(output), std::end(output));
}

copy_bounded() [3/3]

template<std::input_iterator InputIterator, std::output_iterator< typename std::iterator_traits< InputIterator >::value_type > OutputIterator>

OutputIterator CxxUtils::copy_bounded ( InputIterator  begi, InputIterator  endi, OutputIterator  bego, OutputIterator  endo  )

inline

Copy a range with bounds restriction.

Parameters

begi	Start of input range.
endi	End of input range.
bego	Start of output range.
endo	End of output range.

Like std::copy(begi, endi, bego), except that it will not copy more than std::distance(bego, endo) elements.

Copies exactly n = std::min (std::distance(begi,endi), std::distance(bego,endo)) elements. Returns bego + n.

Definition at line 79 of file copy_bounded.h.

{
  return copy_bounded1
    (begi, endi, bego, endo,
     typename std::iterator_traits<InputIterator>::iterator_category(),
     typename std::iterator_traits<OutputIterator>::iterator_category());
}

copy_bounded1() [1/2]

template<class InputIterator , class OutputIterator , class InputTag , class OutputTag >

OutputIterator CxxUtils::copy_bounded1 ( InputIterator  begi, InputIterator  endi, OutputIterator  bego, OutputIterator  endo, const InputTag &  , const OutputTag &    )

inline

Copy a range with bounds restriction; generic version.

Definition at line 31 of file copy_bounded.h.

{
  while (begi != endi && bego != endo) {
    *bego = *begi;
    ++begi;
    ++bego;
  }
  return bego;
}

copy_bounded1() [2/2]

template<class InputIterator , class OutputIterator >

OutputIterator CxxUtils::copy_bounded1 ( InputIterator  begi, InputIterator  endi, OutputIterator  bego, OutputIterator  endo, const std::random_access_iterator_tag &  , const std::random_access_iterator_tag &    )

inline

Copy a range with bounds restriction; random_access_iterator version.

Definition at line 51 of file copy_bounded.h.

{
  size_t n = std::min (endi-begi, endo-bego);
  return std::copy (begi, begi+n, bego);
}

crc64() [1/3]

uint64_t CxxUtils::crc64	(	const char *	data,
		size_t	data_len
	)

Find the CRC-64 of a string, with the default CRC.

Parameters

data	Pointer to the string to hash.
data_len	Length of the string to hash, in bytes.

Definition at line 709 of file crc64.cxx.

{
  return crc64 (defaultCRCTable, data, data_len);
}

crc64() [2/3]

uint64_t CxxUtils::crc64	(	const CRCTable &	table,
		const char *	data,
		size_t	data_len
	)

Find the CRC-64 of a string,.

Parameters

table	Precomputed CRC tables and constants.
data	Pointer to the string to hash.
data_len	Length of the string to hash, in bytes.

This is the default implementation, used on platforms without pclmul.

Definition at line 696 of file crc64.cxx.

{
  return crc64_bytewise (table, data, data_len);
}

crc64() [3/3]

uint64_t CxxUtils::crc64

(

const std::string &

s

)

Find the CRC-64 of a string, using the default polynomial.

Parameters

str	The string to hash.

Definition at line 720 of file crc64.cxx.

{
  return crc64 (defaultCRCTable, s.data(), s.size());
}

crc64_bytewise() [1/3]

uint64_t CxxUtils::crc64_bytewise	(	const char *	data,
		size_t	data_len
	)

Find the CRC-64 of a string, using a byte-by-byte algorithm, with the default CRC.

Parameters

table	Precomputed CRC tables and constants.
data	Pointer to the string to hash.
data_len	Length of the string to hash, in bytes.

Definition at line 580 of file crc64.cxx.

{
  return crc64_bytewise (defaultCRCTable, data, data_len);
}

crc64_bytewise() [2/3]

uint64_t CxxUtils::crc64_bytewise	(	const CRCTable &	table,
		const char *	data,
		size_t	data_len
	)

Find the CRC-64 of a string, using a byte-by-byte algorithm.

Parameters

table	Precomputed CRC tables and constants.
data	Pointer to the string to hash.
data_len	Length of the string to hash, in bytes.

Definition at line 560 of file crc64.cxx.

{
  uint64_t crc = table.m_initial;
  const char* seq = data;
  const char* end = seq + data_len;
  while (seq < end)
    crc = table.m_table[(crc ^ *seq++) & 0xff] ^ (crc >> 8);
  return crc;
}

crc64_bytewise() [3/3]

uint64_t CxxUtils::crc64_bytewise

(

const std::string &

s

)

Find the CRC-64 of a string, using a byte-by-byte algorithm, with the default CRC.

Parameters

table	Precomputed CRC tables and constants.
s	String to hash.

Definition at line 593 of file crc64.cxx.

{
  return crc64_bytewise (defaultCRCTable, s.data(), s.size());
}

crc64addint()

uint64_t CxxUtils::crc64addint	(	uint64_t	crc,
		uint64_t	x
	)

Extend a previously-calculated CRC to include an int.

Parameters

crc	The previously-calculated CRC.
x	The integer to add.

Returns

The new CRC.

Definition at line 732 of file crc64.cxx.

{
  while (x > 0) {
    crc = defaultCRCTable.m_table[(crc ^ x) & 0xff] ^ (crc >> 8);
    x >>= 8;
  }
  return crc;
}

crc64digest()

std::string CxxUtils::crc64digest

(

const std::string &

str

)

Return a CRC-64 digest of a string.

Parameters

str	The string to hash.

Returns

The CRC-64 digest of the string. This is the hash code, expressed as hex as a string.

Definition at line 761 of file crc64.cxx.

{
  return crc64format (crc64 (str));
}

crc64format()

std::string CxxUtils::crc64format

(

uint64_t

crc

)

Format a CRC-64 as a string.

Parameters

crc	The CRC to format.

Definition at line 746 of file crc64.cxx.

{
  char buf[64];
  sprintf (buf, "%08X%08X",
           (unsigned)((crc>>32)&0xffffffff), (unsigned)(crc&0xffffffff));
  return buf;
}

deleteCRCTable()

void CxxUtils::deleteCRCTable

(

CxxUtils::CRCTable *

table

)

Delete a CRCTable object.

Delete a CRC table object.

Definition at line 535 of file crc64.cxx.

{
  delete table;
}

deltaPhi()

template<typename T >

T CxxUtils::deltaPhi ( T  phiA, T  phiB  )

inline

Return difference phiA - phiB in range [-pi, pi].

Definition at line 42 of file phihelper.h.

  {
    static_assert(std::is_floating_point<T>::value);
    return wrapToPi(phiA - phiB);
  }

do_replace()

std::string CxxUtils::do_replace	(	std::string	s,
		const std::string &	pat,
		const std::string &	rep
	)

Definition at line 95 of file normalizeFunctionName.cxx.

{
  std::string::size_type ipos = 0;
  while ((ipos = s.find (pat, ipos)) != std::string::npos)
    s.replace (ipos, pat.size(), rep);
  return s;
}

end() [1/6]

template<class T >

auto CxxUtils::end

(

const range_with_at< T > &

s

)

Definition at line 70 of file range_with_at.h.

{ return s.end(); }

end() [2/6]

template<class T >

auto CxxUtils::end

(

const range_with_conv< T > &

s

)

Definition at line 65 of file range_with_conv.h.

{ return s.end(); }

end() [3/6]

template<class T >

auto CxxUtils::end

(

const span< T > &

s

)

Definition at line 334 of file span.h.

{ return s.end(); }

end() [4/6]

template<class T >

auto CxxUtils::end

(

range_with_at< T > &

s

)

Definition at line 68 of file range_with_at.h.

{ return s.end(); }

end() [5/6]

template<class T >

auto CxxUtils::end

(

range_with_conv< T > &

s

)

Definition at line 63 of file range_with_conv.h.

{ return s.end(); }

end() [6/6]

template<class T >

auto CxxUtils::end

(

span< T > &

s

)

Definition at line 332 of file span.h.

{ return s.end(); }

eraseWhiteSpaces()

std::string_view CxxUtils::eraseWhiteSpaces

(

std::string_view

str

)

Removes all trailing and starting whitespaces from a string.

Definition at line 44 of file Control/CxxUtils/Root/StringUtils.cxx.

                                                        {
        if (str.empty()) return str;
        size_t begin{0}, end{str.size() -1};
        while (std::isspace(str[begin])){
            ++begin;
        }
        while (end > 0 && std::isspace(str[end])){
            --end;
        }
        return str.substr(begin, end + 1);        
    }

exctrace()

void CxxUtils::exctrace	(	const std::exception &	e,
		IOFD	fd = IOFD_INVALID
	)

Print out information for the last exception.

Prints the supplied exception, plus the backtrace from the last exception, if available.

Parameters

e	The exception to print.
fd	The file descriptor to which to write.

Definition at line 59 of file exctrace.cxx.

{
  if (fd == IOFD_INVALID)
    fd = Athena::DebugAids::stacktraceFd();
 
  typedef int (*get_last_trace_fn) (int max_depth, void* trace[]);
  get_last_trace_fn get_last_trace = (get_last_trace_fn) dlsym (RTLD_DEFAULT, "exctrace_get_last_trace");
  
 
  MYWRITELIT(fd, "Exception: ");
  MYWRITE(fd, e.what(), strlen (e.what()));
 
  if (get_last_trace) {
    void* trace[100];
    int depth = get_last_trace (std::end(trace)-std::begin(trace), trace);
 
    MYWRITELIT(fd, "\n");
    // Index 0 is __cxa_throw.  Skip it.
    for (int i = 1; i < depth; ++i) {
      unsigned long ip =
        reinterpret_cast<unsigned long> (trace[i]);
      // A function that throws may have the call to __cxa_throw
      // as the last instruction in the function.  In that case, the IP
      // we see here will be one beyond the end of the function,
      // and we'll report the wrong function.  So move back the IP
      // slightly for the function that threw.
      if (i == 1) --ip;
 
      // It's true that stacktraceLine is not really thread-safe.
      // However, if we're here, things are going south fast anyway,
      // so we'll just cross our fingers and try to shovel out as much
      // information as we can.
      [[maybe_unused]]
      bool dum ATLAS_THREAD_SAFE = stacktraceLine (fd, ip);
    }
  }
  else
    MYWRITELIT(fd, " (no backtrace available).\n");
}

fromArrayrep() [1/2]

template<unsigned int N>

void CxxUtils::fromArrayrep	(	const CaloRec::Arrayrep &	rep,
		CxxUtils::Array< N > &	x
	)

Helper to convert from an @x Arrayrep to an Array.

Parameters

rep	Representation object to convert.
x[out]	Result of the conversion.

fromArrayrep() [2/2]

template<class T >

requires std::assignable_from<T&, float> void CxxUtils::fromArrayrep	(	const CaloRec::Arrayrep &	rep,
		T &	x
	)

Helper to convert from an @x Arrayrep to a scalar type.

Parameters

rep	Representation object to convert.
x[out]	Result of the conversion.

get_unaligned()

template<class T >

T CxxUtils::get_unaligned

(

const uint8_t *ATH_RESTRICT &

p

)

Define templated versions of the above functions.

get_unaligned16()

uint16_t CxxUtils::get_unaligned16 ( const uint8_t *ATH_RESTRICT &  p )

inline

Read a 2-byte little-endian value from a possibly unaligned pointer.

Parameters

p	Pointer from which to read. Advanced to the next value.

Reads a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 63 of file get_unaligned.h.

{
  uint16_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le16toh (ret);
}

get_unaligned32()

uint32_t CxxUtils::get_unaligned32 ( const uint8_t *ATH_RESTRICT &  p )

inline

Read a 4-byte little-endian value from a possibly unaligned pointer.

Parameters

p	Pointer from which to read. Advanced to the next value.

Reads a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 83 of file get_unaligned.h.

{
  uint32_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le32toh (ret);
}

get_unaligned64()

uint64_t CxxUtils::get_unaligned64 ( const uint8_t *ATH_RESTRICT &  p )

inline

Read an 8-byte little-endian value from a possibly unaligned pointer.

Parameters

p	Pointer from which to read. Advanced to the next value.

Reads a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 103 of file get_unaligned.h.

{
  uint64_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le64toh (ret);
}

get_unaligned< double >()

template<>

double CxxUtils::get_unaligned< double > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 195 of file get_unaligned.h.

{
  return get_unaligned_double (p);
}

get_unaligned< float >()

template<>

float CxxUtils::get_unaligned< float > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 187 of file get_unaligned.h.

{
  return get_unaligned_float (p);
}

get_unaligned< int16_t >()

template<>

int16_t CxxUtils::get_unaligned< int16_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 211 of file get_unaligned.h.

{
  return get_unaligned<uint16_t> (p);
}

get_unaligned< int32_t >()

template<>

int32_t CxxUtils::get_unaligned< int32_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 219 of file get_unaligned.h.

{
  return get_unaligned<uint32_t> (p);
}

get_unaligned< int64_t >()

template<>

int64_t CxxUtils::get_unaligned< int64_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 227 of file get_unaligned.h.

{
  return get_unaligned<uint64_t> (p);
}

get_unaligned< int8_t >()

template<>

int8_t CxxUtils::get_unaligned< int8_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 203 of file get_unaligned.h.

{
  return get_unaligned<uint8_t> (p);
}

get_unaligned< uint16_t >()

template<>

uint16_t CxxUtils::get_unaligned< uint16_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 163 of file get_unaligned.h.

{
  return get_unaligned16 (p);
}

get_unaligned< uint32_t >()

template<>

uint32_t CxxUtils::get_unaligned< uint32_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 171 of file get_unaligned.h.

{
  return get_unaligned32 (p);
}

get_unaligned< uint64_t >()

template<>

uint64_t CxxUtils::get_unaligned< uint64_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 179 of file get_unaligned.h.

{
  return get_unaligned64 (p);
}

get_unaligned< uint8_t >()

template<>

uint8_t CxxUtils::get_unaligned< uint8_t > ( const uint8_t *ATH_RESTRICT &  p )

inline

Definition at line 155 of file get_unaligned.h.

{
  return *p++;
}

get_unaligned_double()

double CxxUtils::get_unaligned_double ( const uint8_t *ATH_RESTRICT &  p )

inline

Read a little-endian double value from a possibly unaligned pointer.

Parameters

p	Pointer from which to read. Advanced to the next value.

Reads a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 140 of file get_unaligned.h.

{
  return std::bit_cast<double> (get_unaligned64 (p));
}

get_unaligned_float()

float CxxUtils::get_unaligned_float ( const uint8_t *ATH_RESTRICT &  p )

inline

Read a little-endian float value from a possibly unaligned pointer.

Parameters

p	Pointer from which to read. Advanced to the next value.

Reads a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 123 of file get_unaligned.h.

{
  return std::bit_cast<float> (get_unaligned32 (p));
}

hexdump()

void CxxUtils::hexdump	(	std::ostream &	s,
		const void *	addr,
		size_t	n,
		size_t	offset = 0
	)

Make a hex dump of memory.

Parameters

s	Stream to which to write the output.
addr	Address at which to start dumping.
n	Number of byte to dump.
offset	Offset by which to shift the printed address (mostly for testing).

Definition at line 37 of file hexdump.cxx.

{
  const char* ptr = reinterpret_cast<const char*> (addr);
  size_t ipos = 0;
 
  boost::io::ios_all_saver saver (s);
  std::hex (s);
  s.fill ('0');
 
  char cbuf[width + 1] = {0};
  union {
    uint32_t u32;
    unsigned char uc[4];
  } bbuf;
 
  while (n-- > 0) {
    if ((ipos % width) == 0) {
      s << std::setw(16) << reinterpret_cast<uintptr_t>(ptr + ipos) - offset << " ";
    }
    if ((ipos % 4) == 0) {
      s << " ";
    }
    bbuf.uc[ipos % 4] = ptr[ipos];
    cbuf[ipos % width] = std::isgraph (ptr[ipos]) ? ptr[ipos] : '.';
 
    ++ipos;
    if ((ipos % 4) == 0) {
      s << std::setw(8) << static_cast<unsigned int>(bbuf.u32);
    }
    if ((ipos % width) == 0) {
      s << "  " << cbuf << "\n";
    }
  }
 
  if ((ipos % width) > 0) {
    unsigned ntrail = (ipos % 4);
    if (ntrail > 0) {
      for (unsigned i = ntrail; i < 4; i++) {
        bbuf.uc[i] = 0;
      }
      s << std::setw(2*ntrail) << static_cast<unsigned int>(bbuf.u32);
    }
    while ((ipos % width) != 0) {
      if ((ipos % 4) == 0) {
        s << " ";
      }
      s << "  ";
      cbuf[ipos % width] = ' ';
      ++ipos;
    }
    s << "  " << cbuf << "\n";
  }
}

htole16()

uint16_t CxxUtils::htole16 ( uint16_t  x )

inline

Definition at line 42 of file set_unaligned.h.

{ return x; }

htole32()

uint32_t CxxUtils::htole32 ( uint32_t  x )

inline

Definition at line 43 of file set_unaligned.h.

{ return x; }

htole64()

uint64_t CxxUtils::htole64 ( uint64_t  x )

inline

Definition at line 44 of file set_unaligned.h.

{ return x; }

le16toh()

uint16_t CxxUtils::le16toh ( uint16_t  x )

inline

Definition at line 42 of file get_unaligned.h.

{ return x; }

le32toh()

uint32_t CxxUtils::le32toh ( uint32_t  x )

inline

Definition at line 43 of file get_unaligned.h.

{ return x; }

le64toh()

uint64_t CxxUtils::le64toh ( uint64_t  x )

inline

Definition at line 44 of file get_unaligned.h.

{ return x; }

make_reverse_wrapper()

template<class T >

auto CxxUtils::make_reverse_wrapper

(

T &

r

)

Make a reverse_wrapper for a given container-like object.

Definition at line 46 of file reverse_wrapper.h.

{ return reverse_wrapper(r); }

make_span()

template<detail::IsContiguousContainer CONTAINER>

auto CxxUtils::make_span

(

CONTAINER &

c

)

Helper to make a span from a container.

Parameters

c	The container for which to make a span. It must have contiguous iterators.

Definition at line 319 of file span.h.

{
  return CxxUtils::span (c.data(), c.size());
}

makeCRCTable()

std::unique_ptr< CRCTable > CxxUtils::makeCRCTable	(	uint64_t	p,
		uint64_t	initial = 0xffffffffffffffff
	)

Initialize CRC tables and constants.

Parameters

p	Polynomial for the CRC. A 1 in the 2^64 bit is implied.
initial	Initial CRC value.

Definition at line 547 of file crc64.cxx.

{
  return std::make_unique<CRCTable> (p, initial);
}

max_transformed_element()

template<class RANGE , class FUNC >

auto CxxUtils::max_transformed_element ( RANGE &&  r, FUNC &&  f  )

inline

Find the maximum transformed element in a range.

Parameters

r	Input range.
f	Transform function.

Evaluates f(x) for each x in r and finds the maximum. Returns a pair (fmax, itmax), where fmax is this maximum value, and itmax is an iterator pointing at the corresponding element in r. If more than one element has the same maximum value, the iterator of the first will be returned.

Precondition: Range r is not empty.

Definition at line 82 of file minmax_transformed_element.h.

{
  if (std::ranges::empty (r)) std::abort();
  auto it = std::ranges::begin(r);
  auto itmax = it;
  auto val = f(*it);
  for (++it; it != std::ranges::end(r); ++it) {
    auto val2 = f(*it);
    if (val2 > val) {
      val = val2;
      itmax = it;
    }
  }
  return std::make_pair (val, itmax);
}

min_transformed_element()

template<class RANGE , class FUNC >

auto CxxUtils::min_transformed_element ( RANGE &&  r, FUNC &&  f  )

inline

Find the minimum transformed element in a range.

Parameters

r	Input range.
f	Transform function.

Evaluates f(x) for each x in r and finds the minimum. Returns a pair (fmin, itmin), where fmin is this minimum value, and itmin is an iterator pointing at the corresponding element in r. If more than one element has the same minimum value, the iterator of the first will be returned.

Precondition: Range r is not empty.

Definition at line 50 of file minmax_transformed_element.h.

{
  if (std::ranges::empty (r)) std::abort();
  auto it = std::ranges::begin(r);
  auto itmin = it;
  auto val = f(*it);
  for (++it; it != std::ranges::end(r); ++it) {
    auto val2 = f(*it);
    if (val2 < val) {
      val = val2;
      itmin = it;
    }
  }
  return std::make_pair (val, itmin);
}

munge_names()

std::string CxxUtils::munge_names

(

const std::string &

str_in

)

Definition at line 106 of file normalizeFunctionName.cxx.

{
  std::string s =
    do_replace (str_in, "SG::DataProxyStorageData::pointer", "void*");
  s = do_replace (s, "DPSD::pointer", "void*");
  s = do_replace (s, "SG::auxid_t", "unsigned long");
  s = do_replace (s, "auxid_t", "unsigned long");
  s = do_replace (s, "void* ", "void*");
  s = do_replace (s, "CLID", "unsigned int");
 
  if (s.compare (0, 8, "virtual ") == 0)
    s.erase (0, 8);
  return s;
}

munge_punct()

std::string CxxUtils::munge_punct

(

const std::string &

str_in

)

Definition at line 84 of file normalizeFunctionName.cxx.

{
  std::string s = str_in;
  for (size_t i = 0; i < s.size()-1; i++) {
    if (s[i] == ' ' && (s[i+1] == '*' || s[i+1] == '&'))
      s.erase (i, 1);
  }
  return s;
}

munge_string_name()

std::string CxxUtils::munge_string_name

(

const std::string &

str_in

)

Definition at line 54 of file normalizeFunctionName.cxx.

{
  std::string s = str_in;
 
  std::string::size_type ipos = 0;
  while ((ipos = s.find ("std::basic_string<", ipos)) != std::string::npos) {
    std::string::size_type beg = ipos;
    ipos += 18;
    int inest = 1;
    while (inest > 0 && ipos < s.size()) {
      if (s[ipos] == '<') ++inest;
      else if (s[ipos] == '>') --inest;
      ++ipos;
    }
    s.replace (beg, ipos-beg, "std::string");
    ipos = beg+11;
  }
  
  for (size_t i = 0; i < s.size(); i++) {
    if ((i == 0 || (s[i-1] != ':' && !isalnum(s[i-1]))) &&
        strncmp (s.c_str()+i, "string", 6) == 0 &&
        !isalnum(s[i+6]))
    {
      s.replace (i, 6, "std::string");
    }
  }
  return s;
}

MurmurHash2()

uint32_t CxxUtils::MurmurHash2	(	const void *	key,
		int	len,
		uint32_t	seed
	)

Definition at line 42 of file MurmurHash2.cxx.

{
  // 'm' and 'r' are mixing constants generated offline.
  // They're not really 'magic', they just happen to work well.
 
  const uint32_t m = 0x5bd1e995;
  const int r = 24;
 
  // Initialize the hash to a 'random' value
 
  uint32_t h = seed ^ len;
 
  // Mix 4 bytes at a time into the hash
 
  const unsigned char * data = (const unsigned char *)key;
 
  while(len >= 4)
  {
    uint32_t k = *(uint32_t*)data;
 
    k *= m;
    k ^= k >> r;
    k *= m;
 
    h *= m;
    h ^= k;
 
    data += 4;
    len -= 4;
  }
 
  // Handle the last few bytes of the input array
 
  switch(len)
  {
  case 3: h ^= data[2] << 16;
  // FALLTHROUGH
  case 2: h ^= data[1] << 8;
  // FALLTHROUGH
  case 1: h ^= data[0];
      h *= m;
  };
 
  // Do a few final mixes of the hash to ensure the last few
  // bytes are well-incorporated.
 
  h ^= h >> 13;
  h *= m;
  h ^= h >> 15;
 
  return h;
} 

MurmurHash2A()

uint32_t CxxUtils::MurmurHash2A	(	const void *	key,
		int	len,
		uint32_t	seed
	)

Definition at line 220 of file MurmurHash2.cxx.

{
  const uint32_t M = 0x5bd1e995;
  const int R = 24;
  uint32_t l = len;
 
  const unsigned char * data = (const unsigned char *)key;
 
  uint32_t h = seed;
 
  while(len >= 4)
  {
    uint32_t k = *(uint32_t*)data;
 
    MurmurHash_mmix(h,k);
 
    data += 4;
    len -= 4;
  }
 
  uint32_t t = 0;
 
  switch(len)
  {
  case 3: t ^= data[2] << 16;
  // FALLTHROUGH
  case 2: t ^= data[1] << 8;
  // FALLTHROUGH
  case 1: t ^= data[0];
  };
 
  MurmurHash_mmix(h,t);
  MurmurHash_mmix(h,l);
 
  h ^= h >> 13;
  h *= M;
  h ^= h >> 15;
 
  return h;
}

MurmurHash64A()

uint64_t CxxUtils::MurmurHash64A	(	const void *	key,
		int	len,
		uint64_t	seed
	)

Definition at line 103 of file MurmurHash2.cxx.

{
  const uint64_t m = BIG_CONSTANT(0xc6a4a7935bd1e995);
  const int r = 47;
 
  uint64_t h = seed ^ (len * m);
 
  const uint64_t * data = (const uint64_t *)key;
  const uint64_t * end = data + (len/8);
 
  while(data != end)
  {
    uint64_t k = *data++;
 
    k *= m; 
    k ^= k >> r; 
    k *= m; 
    
    h ^= k;
    h *= m; 
  }
 
  const unsigned char * data2 = (const unsigned char*)data;
 
  switch(len & 7)
  {
  case 7: h ^= uint64_t(data2[6]) << 48;
  // FALLTHROUGH
  case 6: h ^= uint64_t(data2[5]) << 40;
  // FALLTHROUGH
  case 5: h ^= uint64_t(data2[4]) << 32;
  // FALLTHROUGH
  case 4: h ^= uint64_t(data2[3]) << 24;
  // FALLTHROUGH
  case 3: h ^= uint64_t(data2[2]) << 16;
  // FALLTHROUGH
  case 2: h ^= uint64_t(data2[1]) << 8;
  // FALLTHROUGH
  case 1: h ^= uint64_t(data2[0]);
          h *= m;
  };
 
  h ^= h >> r;
  h *= m;
  h ^= h >> r;
 
  return h;
} 

MurmurHash64B()

uint64_t CxxUtils::MurmurHash64B	(	const void *	key,
		int	len,
		uint64_t	seed
	)

Definition at line 155 of file MurmurHash2.cxx.

{
  const uint32_t m = 0x5bd1e995;
  const int r = 24;
 
  uint32_t h1 = uint32_t(seed) ^ len;
  uint32_t h2 = uint32_t(seed >> 32);
 
  const uint32_t * data = (const uint32_t *)key;
 
  while(len >= 8)
  {
    uint32_t k1 = *data++;
    k1 *= m; k1 ^= k1 >> r; k1 *= m;
    h1 *= m; h1 ^= k1;
    len -= 4;
 
    uint32_t k2 = *data++;
    k2 *= m; k2 ^= k2 >> r; k2 *= m;
    h2 *= m; h2 ^= k2;
    len -= 4;
  }
 
  if(len >= 4)
  {
    uint32_t k1 = *data++;
    k1 *= m; k1 ^= k1 >> r; k1 *= m;
    h1 *= m; h1 ^= k1;
    len -= 4;
  }
 
  switch(len)
  {
  case 3: h2 ^= ((unsigned const char*)data)[2] << 16;
  // FALLTHROUGH
  case 2: h2 ^= ((unsigned const char*)data)[1] << 8;
  // FALLTHROUGH
  case 1: h2 ^= ((unsigned const char*)data)[0];
      h2 *= m;
  };
 
  h1 ^= h2 >> 18; h1 *= m;
  h2 ^= h1 >> 22; h2 *= m;
  h1 ^= h2 >> 17; h1 *= m;
  h2 ^= h1 >> 19; h2 *= m;
 
  uint64_t h = h1;
 
  h = (h << 32) | h2;
 
  return h;
} 

MurmurHashAligned2()

uint32_t CxxUtils::MurmurHashAligned2	(	const void *	key,
		int	len,
		uint32_t	seed
	)

Definition at line 324 of file MurmurHash2.cxx.

{
  const uint32_t m = 0x5bd1e995;
  const int r = 24;
 
  const unsigned char * data = (const unsigned char *)key;
 
  uint32_t h = seed ^ len;
 
  int align = (uint64_t)data & 3;
 
  if(align && (len >= 4))
  {
    // Pre-load the temp registers
 
    uint32_t t = 0, d = 0;
 
    switch(align)
    {
      case 1: t |= data[2] << 16;
      // FALLTHROUGH
      case 2: t |= data[1] << 8;
      // FALLTHROUGH
      case 3: t |= data[0];
    }
 
    t <<= (8 * align);
 
    data += 4-align;
    len -= 4-align;
 
    int sl = 8 * (4-align);
    int sr = 8 * align;
 
    // Mix
 
    while(len >= 4)
    {
      d = *(uint32_t *)data;
      t = (t >> sr) | (d << sl);
 
      uint32_t k = t;
 
      MIX(h,k,m);
 
      t = d;
 
      data += 4;
      len -= 4;
    }
 
    // Handle leftover data in temp registers
 
    d = 0;
 
    if(len >= align)
    {
      switch(align)
      {
      case 3: d |= data[2] << 16;
      // FALLTHROUGH
      case 2: d |= data[1] << 8;
      // FALLTHROUGH
      case 1: d |= data[0];
      }
 
      uint32_t k = (t >> sr) | (d << sl);
      MIX(h,k,m);
 
      // At this point, we know that len < 4 and align > 0.
      data += align;
      len -= align;
      // So here, we must have 0 >= len < 3.
 
      //----------
      // Handle tail bytes
 
      switch(len)
      {
      // can't happen --- see above.
      //case 3: h ^= data[2] << 16;
      // FALLTHROUGH
      case 2: h ^= data[1] << 8;
      // FALLTHROUGH
      case 1: h ^= data[0];
          h *= m;
      };
    }
    else
    {
      switch(len)
      {
      // len cannot be 3, because align is at most 3.
      //case 3: d |= data[2] << 16;
      // FALLTHROUGH
      case 2: d |= data[1] << 8;
      // FALLTHROUGH
      case 1: d |= data[0];
      // FALLTHROUGH
      case 0: h ^= (t >> sr) | (d << sl);
          h *= m;
      }
    }
 
    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;
 
    return h;
  }
  else
  {
    while(len >= 4)
    {
      uint32_t k = *(uint32_t *)data;
 
      MIX(h,k,m);
 
      data += 4;
      len -= 4;
    }
 
    //----------
    // Handle tail bytes
 
    switch(len)
    {
    case 3: h ^= data[2] << 16;
    // FALLTHROUGH
    case 2: h ^= data[1] << 8;
    // FALLTHROUGH
    case 1: h ^= data[0];
        h *= m;
    };
 
    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;
 
    return h;
  }
}

MurmurHashNeutral2()

uint32_t CxxUtils::MurmurHashNeutral2	(	const void *	key,
		int	len,
		uint32_t	seed
	)

Definition at line 267 of file MurmurHash2.cxx.

{
  const uint32_t m = 0x5bd1e995;
  const int r = 24;
 
  uint32_t h = seed ^ len;
 
  const unsigned char * data = (const unsigned char *)key;
 
  while(len >= 4)
  {
    uint32_t k;
 
    k  = data[0];
    k |= data[1] << 8;
    k |= data[2] << 16;
    k |= data[3] << 24;
 
    k *= m; 
    k ^= k >> r; 
    k *= m;
 
    h *= m;
    h ^= k;
 
    data += 4;
    len -= 4;
  }
  
  switch(len)
  {
  case 3: h ^= data[2] << 16;
  // FALLTHROUGH
  case 2: h ^= data[1] << 8;
  // FALLTHROUGH
  case 1: h ^= data[0];
          h *= m;
  };
 
  h ^= h >> 13;
  h *= m;
  h ^= h >> 15;
 
  return h;
} 

normalizeFunctionName()

std::string CxxUtils::normalizeFunctionName

(

const std::string &

fname

)

Normalize a pretty-printed C++ function name.

Parameters

fname

The name to normalize.

A C++ compiler can provide a complete printable name of the current function, though for example PRETTY_FUNCTION. This is useful to include in diagnostic messages. However, the exact string generated by different compilers may differ slightly. This can then cause issues if one is trying to compare the output of tests to an expected reference.

This function tries to normalize the function name strings so that they are the same, at least between gcc and clang.

Definition at line 135 of file normalizeFunctionName.cxx.

{
  return munge_names (munge_punct (munge_string_name (clean_allocator (fname))));
}

ones()

template<class T >

constexpr T CxxUtils::ones ( unsigned int  n )

inlineconstexpr

Return a bit mask with the lower n bits set.

Definition at line 25 of file ones.h.

{
  if (n >= sizeof(T) * 8)
    return ~static_cast<T>(0);
  // cppcheck-suppress shiftTooManyBits
  return (static_cast<T>(1) << n) - 1;
}

operator!()

template<typename T , size_t N>

ivec<T, N> CxxUtils::operator! ( const vec_fb< T, N > &  a )

inline

Negation.

Definition at line 158 of file vec_fb.h.

{
  ivec<T, N> c;
  for (size_t i = 0; i < N; ++i)
    c.m_arr[i] = a.m_arr[i] == 0;
  return c;
}

operator&&() [1/3]

template<typename T , size_t N>

ivec<T, N> CxxUtils::operator&& ( const vec_fb< T, N > &  a, const vec_fb< T, N > &  b  )

inline

V1 && V2.

Definition at line 169 of file vec_fb.h.

{
  ivec<T, N> c;
  for (size_t i = 0; i < N; ++i)
    c.m_arr[i] = (a.m_arr[i] != 0) & (b.m_arr[i] != 0);
  return c;
}

operator&&() [2/3]

template<typename T , size_t N, class U >

ivec<T, N> CxxUtils::operator&& ( const vec_fb< T, N > &  a, U  b  )

inline

V && S.

Definition at line 191 of file vec_fb.h.

{
  ivec<T, N> c;
  for (size_t i = 0; i < N; ++i)
    c.m_arr[i] = (a.m_arr[i] != 0) & (b ? -1 : 0);
  return c;
}

operator&&() [3/3]

template<typename T , size_t N, class U >

ivec<T, N> CxxUtils::operator&& ( U  a, const vec_fb< T, N > &  b  )

inline

S && V.

Definition at line 180 of file vec_fb.h.

{
  ivec<T, N> c;
  for (size_t i = 0; i < N; ++i)
    c.m_arr[i] = a ? b.m_arr[i] != 0 : 0;
  return c;
}

operator<<()

template<unsigned int N>

std::ostream& CxxUtils::operator<<	(	std::ostream &	s,
		const Array< N > &	a
	)

operator||()

template<typename T , size_t N>

ivec<T, N> CxxUtils::operator|| ( const vec_fb< T, N > &  a, const vec_fb< T, N > &  b  )

inline

V1 || V2.

Definition at line 202 of file vec_fb.h.

{
  ivec<T, N> c;
  for (size_t i = 0; i < N; ++i)
    c.m_arr[i] = (a.m_arr[i] != 0) | (b.m_arr[i] != 0);
  return c;
}

phiBisect()

template<typename T >

T CxxUtils::phiBisect ( T  phiA, T  phiB  )

inline

Bisect (average) the angle spanned by phiA and phiB.

The average is calculated by rotating phiA half-way counter-clockwise onto phiB. Note that his method is not symmetric in its arguments. Typical use-cases are to determine the centre of a region in the detector.

The returned value is within the range [-pi, pi].

Definition at line 77 of file phihelper.h.

  {
    static_assert(std::is_floating_point<T>::value);
    T phi = 0.5 * (phiA + phiB);
    if (phiA > phiB) phi += M_PI;
    return wrapToPi(phi);
  }

phiMean()

template<typename T >

T CxxUtils::phiMean ( T  phiA, T  phiB  )

inline

Calculate average of two angles.

The average is calculated as the angle of the sum of the two unit vectors with angles phiA and phiB. As such it always returns the angle in the narrower of the two complimentary regions spanned by phiA and phiB. If the vector sum is zero, return the angle within [-pi/2, pi/2]. This method is symmetric in its arguments except if |mean| equals pi.

The returned value is within the range [-pi, pi].

Definition at line 60 of file phihelper.h.

  {
    static_assert(std::is_floating_point<T>::value);
    const T diff = wrapToPi(phiA - phiB);
    return wrapToPi(phiB + 0.5 * diff);
  }

prefetchN()

template<size_t N>

void CxxUtils::prefetchN ( const void *  ptr )

inline

Prefetch an N-byte block of memory.

Parameters

[in]

ptr

Starting address of the block.

Definition at line 85 of file prefetch.h.

{
  const char* pp = reinterpret_cast<const char*> (ptr);
 
  // The compiler will unroll this loop for small N.
  for (size_t i = 0; i < N; i += CacheLineSize)
    prefetchOne (pp + i);
 
  // Issue a prefetch for the last byte as well, in case it crosses
  // cache lines.
  prefetchOne (pp + N - 1);
}

prefetchNext()

template<typename Iter >

void CxxUtils::prefetchNext ( Iter  iter, Iter  endIter  )

inline

Prefetch next object in sequence.

Parameters

iter	Current iteration position.
endIter	End of the sequence.

Iter is a ForwardIterator over pointers.

Prefetches next object in a collection of pointers. Accepts two iterators: the first iterator is the current iteration position, and the second iterator is the end iterator for the whole sequence. The first iterator must not be equal to the end iterator (this is not checked). This increments the iterator and, if not equal to the end, prefetches the complete object referenced by the pointer.

Definition at line 130 of file prefetch.h.

{
  if (++iter != endIter)
    prefetchObj(*iter);
}

prefetchObj()

template<typename T >

void CxxUtils::prefetchObj ( const T *  ptr )

inline

Generic prefetch of the object of specific types (sizes).

Parameters

[in]

address

memory location to prefetch

This method will prefetch as many cache lines as needed to store the object of the specified type in memory. Type is specified as a template argument.

Definition at line 108 of file prefetch.h.

{
  prefetchN<sizeof(T)> (ptr);
}

prefetchOne()

void CxxUtils::prefetchOne ( const void *  address )

inline

Generic prefetch method.

Parameters

[in]

address

memory location to prefetch

This is generic method that does not have any extra behavior. It only prefetches the whole cache line which contains the specified memory location. It does not incur any additional overhead and may be the most efficient method for small objects which have a high chance of being on just a single cache line.

Definition at line 73 of file prefetch.h.

{
  CXXUTILS_PREFETCH_ADDRESS(address);
}

prefetchTwo()

template<typename Iter >

void CxxUtils::prefetchTwo ( Iter  iter, Iter  endIter  )

inline

Prefetch two objects.

Parameters

iter	Current iteration position.
endIter	End of the sequence.

Iter is a ForwardIterator over pointers.

Prefetches the current and next objects in a collection of pointers. Accepts two iterators: the first iterator is the current iteration position, and the second is the end iterator for the whole sequence. If the first iterator is not equal to end the iterator, the object to which it points is prefetched. Then the iterator is incremented and, if not equal to the end iterator, the next objects is also prefetched.

Definition at line 154 of file prefetch.h.

{
  if (iter != endIter) {
    prefetchObj(*iter);
    if (++iter != endIter) {
      prefetchObj(*iter);
    }
  }
}

requires() [1/5]

template<class KEY , class VALUE , template< class > class UPDATER, class HASHER = std::hash<KEY>, class MATCHER = std::equal_to<KEY>, detail::ConcurrentHashmapVal_t NULLVAL = 0, detail::ConcurrentHashmapVal_t TOMBSTONE = NULLVAL>

CxxUtils::requires

(

detail::IsConcurrentHashmapPayload< KEY > &&detail::IsConcurrentHashmapPayload< VALUE > &&detail::IsUpdater< UPDATER > &&detail::IsHash< HASHER, KEY > &&detail::IsBinaryPredicate< MATCHER, KEY >

)

Hash map from integers/pointers allowing concurrent, lockless reads.

This class implements a hash map. Both the key and mapped types may be pointers or any numeric type that can fit in a uintptr_t. (However, using floating types for the key is not recommended.) It allows for concurrent access from many threads. Reads can proceed without taking out a lock, while writes are serialized with each other. Thus, this is appropriate for maps which are read-mostly.

This is based on ConcurrentHashmapImpl.

Besides the mapped key and value types, this class is templated on an UPDATER class, which is used to manage the underlying memory. See IsUpdater.h for details. (AthenaKernel/RCUUpdater is a concrete version that should work in the context of Athena.)

The operations used for calculating the hash of the keys and comparing keys can be customized with the HASHER and MATCHER template arguments (though the defaults should usually be fine).

One value of the key must be reserved as a null value, which no real keys may take. By default this is ‘0’, but it may be customized with the NULLVAL template argument. The map may optionally support erasures (via tombstones). To allow this, a second reserved key value must be identified and specified by the TOMBSTONE template argument. Note that the type of the NULLPTR and TOMBSTONE template arguments is a uintptr_t, not KEY.

This mostly supports the interface of std::unordered_map, with a few differences / omissions:

• Dereferencing the iterator returns a structure by value, not a reference.
• No try_emplace.
• No insert methods with hints.
• No operator==.
• Nothing dealing with the bucket/node interface or merge().

Performance: This is the result from running the test with –perf on my machine, with gcc 13.0.0

ConcurrentMap lookup: 0.843s wall, 0.840s user + 0.000s system = 0.840s CPU (99.6%) iterate: 0.551s wall, 0.540s user + 0.000s system = 0.540s CPU (97.9%) UnorderedMap lookup: 1.890s wall, 1.870s user + 0.000s system = 1.870s CPU (99.0%) iterate: 0.966s wall, 0.970s user + 0.000s system = 0.970s CPU (100.4%) concurrent_unordered_map lookup: 3.718s wall, 3.690s user + 0.010s system = 3.700s CPU (99.5%) iterate: 5.719s wall, 5.690s user + 0.000s system = 5.690s CPU (99.5%) ck_ht lookup: 1.471s wall, 1.460s user + 0.000s system = 1.460s CPU (99.2%) iterate: 1.519s wall, 1.500s user + 0.000s system = 1.500s CPU (98.7%)

The timing for the lookup test of UnorderedMap is probably overly-optimistic, since the test doesn't do any locking in that case.

Representation type in the underlying map.

The underlying uint->uint hash table.

Standard STL types.

Updater object.

Context type.

Type for external locking.

Ensure that the underlying map can store our types.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another map.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from a range of pairs.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the map.

Test if the map is currently empty.

Return the current size (capacity) of the hash table.

The number of erased elements in the current table.

Value structure for iterators.

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire map.

Iterator at the start of the map.

Iterator at the end of the map.

Iterator at the start of the map.

Iterator at the end of the map.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Take a lock on the container.

Take a lock on the container. The lock can then be passed to insertion methods, allowing to factor out the locking inside loops. The lock will be released when the lock object is destroyed.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the key and second is the integer value.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

For external locking, use emplace().

Insert a range of elements to the map.

Parameters

first	Start of the range.
last	End of the range.

The range should be a sequence of pairs where first is the string key and second is the integer value.

Erase an entry from the table.

Parameters

key	The key to erase.

Mark the corresponding entry as deleted. Return true on success, false on failure (key not found).

The tombstone value must be different from the null value.

This may cause the key type returned by an iterator to change asynchronously to the tombstone value.

Erase an entry from the table, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key to erase.

Mark the corresponding entry as deleted. Return true on success, false on failure (key not found).

The tombstone value must be different from the null value.

This may cause the key type returned by an iterator to change asynchronously to the tombstone value.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Erase the table and change the capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

Erase the table (don't change the capacity).

Parameters

ctx	Execution context.

Erase the table in-place.

This method avoids allocating a new version of the table. However, it is not safe to use concurrently — no other threads may be accessing the container at the same time, either for read or write.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap. The Hasher and Matcher instances are NOT swapped.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to this type's key value.

Parameters

val	The underlying key value.

Convert this type's key value to an underlying key value.

Parameters

k

The key.

Convert an underlying mapped value to this type's mapped value.

Parameters

val	The underlying mapped value.

Convert this type's mapped value to an underlying mapped value.

Parameters

val	The mapped value.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert / overwrite an entry in the table.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
overwrite	If true, allow overwriting an existing entry.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert / overwrite an entry in the table, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
overwrite	If true, allow overwriting an existing entry.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

The underlying hash table.

Definition at line 94 of file ConcurrentMap.h.

{
private:
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
  // Translate between the Hasher/Matcher provided (which take KEY arguments)
  // and what we need to give to the underlying implementation
  // (which takes a uintptr_t).
  struct Hasher
  {
    size_t operator() (val_t k) const {
      return m_h (keyAsKey (k));
    }
    HASHER m_h;
  };
  struct Matcher
  {
    bool operator() (val_t a, val_t b) const {
      return m_m (keyAsKey (a), keyAsKey (b));
    }
    MATCHER m_m;
  };
 
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER,
                                                        Hasher,
                                                        Matcher,
                                                        NULLVAL,
                                                        TOMBSTONE>;
 
 
public:
  using key_type = KEY;
  using mapped_type = VALUE;
  using size_type = size_t;
  using Updater_t = typename Impl_t::Updater_t;
  using Context_t = typename Updater_t::Context_t;
  using Lock_t = typename Impl_t::Lock_t;
 
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(key_type) );
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(mapped_type) );
 
 
  ConcurrentMap (Updater_t&& updater,
                 size_type capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
  ConcurrentMap (const ConcurrentMap& other,
                 Updater_t&& updater,
                 size_t capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentMap (InputIterator f,
                 InputIterator l,
                 Updater_t&& updater,
                 size_type capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentMap (const ConcurrentMap& other) = delete;
  ConcurrentMap (ConcurrentMap&& other) = delete;
  ConcurrentMap& operator= (const ConcurrentMap& other) = delete;
  ConcurrentMap& operator= (ConcurrentMap&& other) = delete;
 
 
  ~ConcurrentMap() = default;
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  size_t erased() const;
 
 
  using const_iterator_value = std::pair<const key_type, mapped_type>;
 
 
  class const_iterator
    : public boost::iterator_facade<const_iterator,
                                    const const_iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const const_iterator_value>
  {
  public:
    const_iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    const const_iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
 
 
  const_iterator_range range() const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (key_type key) const;
 
 
  size_type count (key_type key) const;
 
 
  const_iterator find (key_type key) const;
 
 
  mapped_type at (key_type key) const;
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (key_type key) const;
 
 
  Lock_t lock();
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           key_type key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (key_type key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const Lock_t& lock,
                    key_type key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (const PAIR& p);
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last);
 
 
  bool erase (key_type key);
 
 
  bool erase (const Lock_t& lock, key_type key);
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void clear (size_t capacity,
              const Context_t& ctx = Updater_t::defaultContext());
 
 
  void clear (const Context_t& ctx = Updater_t::defaultContext());
 
 
  void forceClear();
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentMap& other);
 
 
  Updater_t& updater();
 
 
private:
  static key_type keyAsKey (val_t val);
 
 
  static val_t keyAsVal (key_type k);
 
 
  static mapped_type mappedAsMapped (val_t val);
 
 
  static val_t mappedAsVal (mapped_type val);
 
 
  typename Impl_t::const_iterator get (key_type key) const;
 
 
  std::pair<const_iterator, bool>
  put (key_type key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       key_type key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  Impl_t m_impl;
};

requires() [2/5]

template<class KEY , class VALUE , template< class > class UPDATER, class HASHER = std::hash<KEY>, class MATCHER = std::equal_to<KEY>, detail::ConcurrentHashmapVal_t NULLVAL = 0>

CxxUtils::requires

(

detail::IsConcurrentHashmapPayload< KEY > &&detail::IsUpdater< UPDATER > &&detail::IsHash< HASHER, KEY > &&detail::IsBinaryPredicate< MATCHER, KEY >

)

Hash map from pointers/integers to arbitrary objects allowing concurrent, lockless reads.

This class implements a hash map, using keys that may be pointers or any integer type that can fit in an uintptr_t. The mapped type is arbitrary. It allows for concurrent access from many threads. Reads can proceed without taking out a lock, while writes are serialized with each other. Thus, this is appropriate for maps which are read-mostly.

This class includes non-const references that can be used to obtain non-const references to the mapped objects. Howeer, the mapped objects must themselves the thread-safe in order to safely modify them in a multithreaded context.

This is based on ConcurrentHashmapImpl.

Besides the key and mapped value types, this class is templated on an UPDATER class, which is used to manage the underlying memory. See IsUpdater.h for details. (AthenaKernel/RCUUpdater is a concrete version that should work in the context of Athena.)

The operations used for calculating the hash of the keys and comparing keys can be customized with the HASHER and MATCHER template arguments (though the defaults should usually be fine).

One value of the key must be reserved as a null value, which no real keys may take. By default this is ‘0’, but it may be customized with the NULLVAL template argument. Note that the type of the NULLPTR template argument is a uintptr_t, not KEY.

This mostly supports the interface of std::unordered_map, with a few differences / omissions:

• Dereferencing the iterator returns a structure by value, not a reference.
• No try_emplace.
• No insert methods with hints.
• No clear / erase / overwrite. Those could be implemented if needed (but would require some extra complexity in the memory management).
• No operator==.
• Nothing dealing with the bucket/node interface or merge().

The mapped value can be given as any of:

• A value or const reference. In that case, it needs to be copy-constructable.
• A rvalue-reference. In that case, it needs to be movable.
• A unique_ptr to an instance.

I.e., any of these should work:

CxxUtils::ConcurrentToValMap<int, Payload> map;
const Payload p (1);
map.emplace (1, p);  // By value / const reference
map.emplace (2, Payload (2));  // By rvalue-reference.
                               // Could also move() an instance.
map.emplace (3, std::make_unique<Payload> (3));  // By unique_ptr.

Representation type in the underlying map.

The underlying uint->uint hash table.

Standard STL types.

Updater object.

Context type.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another map.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from a range of pairs.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the map.

Test if the map is currently empty.

Return the current size (capacity) of the hash table.

Value structures for iterators.

For a map from K to V, a STL-style iterator should dereference to a std::pair<const K, V>. However, we don't actually store an object like that anywhere. In order to be able to have STL-like iterators, we instead use a pair where the second element is a const reference to the mapped value. We will return this by value when we deference an iterator. (The compiler should be able to optimize out the redundant packing and unpacking of fields.)

Const iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Conversion from non-const iterator (for interoperability).

Parameters

other

The other iterator.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a iterator_value by value, we also need to override the reference type.

From this, we can get a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire map.

Return an iterator range covering the entire map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Iterator at the start of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the end of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

The mapped object must itself be thread-safe in order to make any changes to it through the returned iterator.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

This returns a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert a range of elements to the map.

Parameters

first	Start of the range.
last	End of the range.
ctx	Execution context.

The range should be a sequence of pairs where first is the string key and second is the integer value.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to this type's key value.

Parameters

val	The underlying key value.

Convert this type's key value to an underlying key value.

Parameters

k

The key.

Convert an underlying mapped value a pointer to this type's mapped value.

Parameters

val	The underlying mapped value.

Convert this type's mapped value to an underlying mapped value.

Parameters

val	The mapped value.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert an entry in the table.

Parameters

key	The key of the new item to add.
val	The new mapped value to add.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

The underlying hash table.

Definition at line 98 of file ConcurrentToValMap.h.

{
private:
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
  // Translate between the Hasher/Matcher provided (which take KEY arguments)
  // and what we need to give to the underlying implementation
  // (which takes a uintptr_t).
  struct Hasher
  {
    size_t operator() (val_t k) const {
      return m_h (keyAsKey (k));
    }
    HASHER m_h;
  };
  struct Matcher
  {
    bool operator() (val_t a, val_t b) const {
      return m_m (keyAsKey (a), keyAsKey (b));
    }
    MATCHER m_m;
  };
 
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER,
                                                        Hasher,
                                                        Matcher,
                                                        NULLVAL>;
 
 
public:
  using key_type = KEY;
  using mapped_type = VALUE;
  using size_type = size_t;
  using Updater_t = typename Impl_t::Updater_t;
  using Context_t = typename Updater_t::Context_t;
 
 
  ConcurrentToValMap (Updater_t&& updater,
                      size_type capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentToValMap (const ConcurrentToValMap& other,
                      Updater_t&& updater,
                      size_t capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentToValMap (InputIterator f,
                      InputIterator l,
                      Updater_t&& updater,
                      size_type capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentToValMap (const ConcurrentToValMap& other) = delete;
  ConcurrentToValMap (ConcurrentToValMap&& other) = delete;
  ConcurrentToValMap& operator= (const ConcurrentToValMap& other) = delete;
  ConcurrentToValMap& operator= (ConcurrentToValMap&& other) = delete;
 
 
  ~ConcurrentToValMap();
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  using const_iterator_value = std::pair<const key_type, const mapped_type&>;
  using iterator_value = std::pair<const key_type, mapped_type&>;
 
  class const_iterator;
  class iterator;
 
 
  class const_iterator
    : public boost::iterator_facade<const_iterator,
                                    const const_iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const const_iterator_value>
  {
  public:
    const_iterator (typename Impl_t::const_iterator it);
 
 
    const_iterator (const iterator& other);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
    friend class iterator;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    bool equal (const iterator& other) const;
 
 
    const const_iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  class iterator
    : public boost::iterator_facade<iterator,
                                    const iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const iterator_value>
  {
  public:
    iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
    friend class const_iterator;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const iterator& other) const;
 
 
    bool equal (const const_iterator& other) const;
 
 
    const iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
  typedef boost::iterator_range<iterator> iterator_range;
 
 
  const_iterator_range range() const;
 
 
  iterator_range range();
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  iterator begin();
 
 
  iterator end();
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (const key_type key) const;
 
 
  size_type count (const key_type key) const;
 
 
  const_iterator find (const key_type key) const;
 
 
  iterator find (const key_type key);
 
 
  const mapped_type& at (const key_type key) const;
 
 
  mapped_type& at (const key_type key);
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (const key_type key) const;
 
 
  std::pair<iterator, iterator>
  equal_range (const key_type key);
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, const mapped_type& val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, mapped_type&& val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, std::unique_ptr<mapped_type> val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (const PAIR& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (PAIR&& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last,
               const Context_t& ctx = Updater_t::defaultContext());
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentToValMap& other);
 
 
  Updater_t& updater();
 
 
private:
  static key_type keyAsKey (val_t val);
 
 
  static val_t keyAsVal (key_type k);
 
 
  static mapped_type* mappedAsMapped (val_t val);
 
 
  static val_t mappedAsVal (mapped_type* val);
 
 
  typename Impl_t::const_iterator get (const key_type key) const;
 
 
  std::pair<const_iterator, bool>
  put (const key_type key,
       std::unique_ptr<mapped_type> val,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  Impl_t m_impl;
};

requires() [3/5]

template<class VALUE , template< class > class UPDATER>

CxxUtils::requires

(

detail::IsConcurrentHashmapPayload< VALUE > &&detail::IsUpdater< UPDATER >

)

Hash map from strings allowing concurrent, lockless reads.

This class implements a hash map from strings. The mapped type may be a pointer or any numeric type that can fit in a uintptr_t. It allows for concurrent access from many threads. Reads can proceed without taking out a lock, while writes are serialized with each other. Thus, this is appropriate for maps which are read-mostly.

This is based on ConcurrentHashmapImpl.

Besides the mapped value type, this class is templated on an UPDATER class, which is used to manage the underlying memory. See IsUpdater.h for details. (AthenaKernel/RCUUpdater is a concrete version that should work in the context of Athena.)

This mostly supports the interface of std::unordered_map, with a few differences / omissions:

• Dereferencing the iterator returns a structure by value, not a reference.
• No try_emplace.
• No insert methods with hints.
• No clear(). Could be implemented if really needed; we would need to be able to attach the key strings to be deleted to the old table instance.
• No erase() methods. In addition to what's needed for clear(), the underlying hash table would need to support tombstones.
• No operator==.
• Nothing dealing with the bucket/node interface or merge().

Possible improvements:

• We could speed up lookups further by storing the hash along with the string. That way, we should almost always not have to do the full string comparison more than once.
• We could use a more efficient allocator for the string keys that we need to save. That could in particular help for updates, where currently we always need to allocate a string, and then need to delete it if it turns out we're doing an update rather than in insertion.

The underlying uint->uint hash table.

Representation type in the underlying map.

Standard STL types.

Updater object.

Context type.

Type for external locking.

Ensure that the underlying map can store our mapped_type.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another map.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from a range of pairs.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the map.

Test if the map is currently empty.

Return the current size (capacity) of the hash table.

Value structure for iterators.

For a map from K to V, a STL-style iterator should dereference to a std::pair<const K, V>. However, we don't actually store an object like that anywhere. In order to be able to have STL-like iterators, we instead use a pair where the first element is a const reference to the std::string key. We will return this by value when we deference an iterator. (The compiler should be able to optimize out the redundant packing and unpacking of fields.)

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire map.

Iterator at the start of the map.

Iterator at the end of the map.

Iterator at the start of the map.

Iterator at the end of the map.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Take a lock on the container.

Take a lock on the container. The lock can then be passed to insertion methods, allowing to factor out the locking inside loops. The lock will be released when the lock object is destroyed.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map, or overwrite an existing one, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

For external locking, use emplace().

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert a range of elements to the map.

Parameters

first	Start of the range.
last	End of the range.
ctx	Execution context.

The range should be a sequence of pairs where first is the string key and second is the integer value.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to a string pointer.

Parameters

val	The underlying key value.

Convert a string pointer to an underlying key value.

Parameters

s	The string pointer.

Convert an underlying mapped value to this type's mapped value.

Parameters

val	The underlying mapped value.

Convert this type's mapped value to an underlying mapped value.

Parameters

val	The mapped value.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert / overwrite an entry in the table.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
overwrite	If true, allow overwriting an existing entry.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert / overwrite an entry in the table, with external locking.

Parameters

lock	The lock object returned from lock().
val	The value of the new item to add.
overwrite	If true, allow overwriting an existing entry.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Hash functional for keys.

The key can be either a std::string or the representation type used by the underlying map.

Hash function from the underlying representation type.

Hash function from a std::string.

Hash functional.

Matching functional for keys.

Compare two keys (as the underlying representation type) for equality.

The underlying hash table.

Definition at line 74 of file ConcurrentStrMap.h.

{
private:
  struct Hasher;
  struct Matcher;
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER, Hasher, Matcher>;
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
 
public:
  using key_type = std::string;
  using mapped_type = VALUE;
  using size_type = size_t;
  using Updater_t = typename Impl_t::Updater_t;
  using Context_t = typename Updater_t::Context_t;
  using Lock_t = typename Impl_t::Lock_t;
 
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(mapped_type) );
 
 
  ConcurrentStrMap (Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
  ConcurrentStrMap (const ConcurrentStrMap& other,
                    Updater_t&& updater,
                    size_t capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentStrMap (InputIterator f,
                    InputIterator l,
                    Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentStrMap (const ConcurrentStrMap& other) = delete;
  ConcurrentStrMap (ConcurrentStrMap&& other) = delete;
  ConcurrentStrMap& operator= (const ConcurrentStrMap& other) = delete;
  ConcurrentStrMap& operator= (ConcurrentStrMap&& other) = delete;
 
 
  ~ConcurrentStrMap();
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  using const_iterator_value = std::pair<const key_type&, mapped_type>;
 
 
  class const_iterator
    : public boost::iterator_facade<const_iterator,
                                    const const_iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const const_iterator_value>
  {
  public:
    const_iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    const const_iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
 
 
  const_iterator_range range() const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (const key_type& key) const;
 
 
  size_type count (const key_type& key) const;
 
 
  const_iterator find (const key_type& key) const;
 
 
  mapped_type at (const std::string& key) const;
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (const key_type& key) const;
 
 
  Lock_t lock();
 
 
  std::pair<const_iterator, bool>
  emplace (const key_type& key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           const key_type& key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (key_type&& key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           key_type&& key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const key_type& key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const Lock_t& lock,
                    const key_type& key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (key_type&& key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const Lock_t& lock,
                    key_type&& key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (const PAIR& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (PAIR&& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last,
               const Context_t& ctx = Updater_t::defaultContext());
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentStrMap& other);
 
 
  Updater_t& updater();
 
 
private:
  static const std::string* keyAsString (val_t val);
 
 
  static val_t keyAsVal (const std::string* s);
 
 
  static mapped_type mappedAsMapped (val_t val);
 
 
  static val_t mappedAsVal (mapped_type val);
 
 
  typename Impl_t::const_iterator get (const key_type& key) const;
 
 
  std::pair<const_iterator, bool>
  put (std::unique_ptr<key_type> key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       std::unique_ptr<key_type> key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  struct Hasher
  {
    size_t operator() (const val_t p) const;
    size_t operator() (const std::string& s) const;
    std::hash<std::string> m_hash;
  };
 
 
  struct Matcher
  {
    bool operator() (const val_t a, const val_t b) const;
  };
 
 
  Impl_t m_impl;
};

requires() [4/5]

template<class RANGE , class KEY , class T , class COMPARE , template< class > class UPDATER>

CxxUtils::requires

(

detail::IsUpdater< UPDATER > &&detail::IsConcurrentRangeCompare< COMPARE, RANGE, KEY, typename UPDATER< int >::Context_t >

)

Map from range to payload object, allowing concurrent, lockless reads.

This class implements a map of sorted ‘range’ objects (though only a single value is actually used) to allocated payload objects. Values can be looked up by a key; the value returned will be the first for which the range is not less than the key. We also support insertions, erasures, and iteration.

The only thing we need to do with the contained pointers is to delete them. Rather than doing that directly, we take a deletion object as an argument to the constructor. This allows one to instantiate this template with void as T, to reduce the amount of generated code. The emplace method takes a unique_ptr as an argument. We define payload_unique_ptr which is a unique_ptr to T that does deletion by calling an arbitrary function. payload_unique_ptr may be initialized from a unique_ptr; to construct one directly, the deletion function should be passed as a second argument to the payload_unique_ptr constructor.

There can be only one writer at a time; this is enforced with internal locks. However, there can be any number of concurrent readers at any time. The reads are lockless (but not necessarily waitless, though this should not be significant in practice). So this is appropriate when reads are much more frequent than writes.

This implementation also assumes that a lookup is most likely to be for the last element in the map, that insertions are most likely to be at the end, and that erasures are most likely to be from the beginning. This class will still work if these assumptions are violated, but it may be much slower. (The use case for which this was targeted was that of conditions containers.)

Template arguments: RANGE - The type of the range object stored with each element. KEY - The type used to look up objects in the container. This may be same as RANGE, but not necessarily. (For example, RANGE may contain start and end times, while KEY may be a single time.) COMPARE - Object used for key comparisons; see below. UPDATER - Object used for memory management; see below.

COMPARE should implement a less-than relation, like a typical STL comparison object, with these signatures:

bool operator() (const KEY& k1,   const RANGE& r2) const;
bool operator() (const RANGE& r1, const RANGE& r2) const;
bool inRange (const KEY& k, const RANGE& r) const;
 
// Test if two ranges overlap, and adjust if needed.
// OLDRANGE is an existing range in the container, and NEWRANGE
// is a new one being added.  Return one of:
//   0 -- no overlap between the ranges; NEWRANGE is unmodified.
//   1 -- ranges overlap.  NEWRANGE has been adjusted to avoid the overlap.
//        If the start of NEWRANGE is changed, it must
//        only be moved forward (increased), never backwards.
//  -1 -- duplicate: NEWRANGE is entirely inside OLDRANGE.
//        Delete the new range.         
int overlap (const Context_t& ctx,
             const RANGE& oldRange, RANGE& newRange) const;
 
// Possibly extend an existing range at the end.
// RANGE is the existing range, and NEWRANGE is the range
// being added.  Returns one of:
// Required only for extendLastRange --- which see.
//   0 -- no change was made to RANGE.
//   1 -- RANGE was extended. 
//  -1 -- newRange is a duplicate.
int extendRange (Range& range, const Range& newRange) const;

In order to implement updating concurrently with reading, we need to defer deletion of objects until no thread can be referencing them any more. The policy for this for the internal implementation objects is set by the template UPDATER<T>. For details, see IsUpdater.h.

Deletion of payload objects is managed via the IRangeMapPayloadDeleter object passed to the constructor.

Implementation notes: The values we store are pairs of RANGE, const T*. The data are stored in a vector of such values. We maintain atomic pointers to the first and last valid elements in the map. We can quickly add an element to the end or delete an element from the beginning by adjusting these pointers. Any other changes will require making a new copy of the data vector.

Function to delete a T*

unique_ptr deletion class for a payload object.

We can't use the unique_ptr default because we want to allow instantiating with a void.

Initialize with an explicit deletion function.

Allow initializing a payload_unique_ptr from a std::unique_ptr<U>.

Delete a pointer.

The deletion function.

unique_ptr holding a payload object.

One may initialize an instance of this in one of two ways. First, from another std::unique_ptr:

payload_unique_ptr p = std::unique_ptr<U> (...);

where U* must be convertible to T*. In this case, the pointer will be deleted as a U*. Second, one can supply an explicit deletion function:

T* tp = ...;
payload_unique_ptr p (tp, delfcn);

Holds one version of the map.

This object holds one version of the map. Within a single version, we can add elements to the end or remove elements from the beginning. If we need to make other changes, or to expand the map, we must make a new version and copy the contents. The UPDATER object is then used to install the new version; old versions should be kept until they are no longer referenced by any thread.

Constructor.

Parameters

capacity

Size of the data vector to allocate.

Destructor.

Return a pointer to the start of the data vector.

Return the size of the current data vector.

Vector holding the map data.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
payloadDeleter	Object for deleting payload objects. This is owned via a shared_ptr.
capacity	Initial capacity of the map.
compare	Comparison object.

Destructor.

Clean up any remaining payload objects.

Return a reference to the payload deleter object.

Return a reference to the payload deleter object.

Search for the first item less than or equal to KEY.

Parameters

key	The key to search for.

Returns

The value, or nullptr if not found.

Results returned from emplace().

All ok.

New object was added, but overlaps with an existing range.

New object duplicates an existing range, and was not added.

Add a new element to the map.

Parameters

range	Validity range for this element.
ptr	Payload for this element.
tryExtend	If true, then allow an existing range to be extended (see below).
ctx	Execution context.

Returns SUCCESS if the new element was successfully inserted. Returns DUPLICATE if the range compared equal to an existing one. In that case, no new element is inserted (and ptr gets deleted). Returns EXTEND if the range of the last element was extended to range. This happens if tryExtend is true, range is equal to the range of the last element (according to m_compare), and the range can be extended according to extendRange. (This will generally mean that the start time of range matches the last range, and end time of range is after the end time of the last range.) In this case, again no new element is inserted and ptr is deleted. Returns OVERLAP if the range of the new element overlaps an existing element (the new element is still inserted).

Erase the first item less than or equal to KEY.

Parameters

key	The key to search erase.
ctx	Execution context.

Extend the range of the last entry of the map.

Parameters

newRange	New range to use for the last entry.
ctx	Execution context.

The range of the last entry in the map is updated to newRange. Does nothing if the map is empty. This will make a new version of implementation data.

The semantics of what it means to extend a range are given by the extendRange method of the COMPARE object (see above).

Returns -1 if there was an error; 1 if the last range was extended; and 0 if nothing was changed.

Update all range objects.

Parameters

rangeUpdater	Functional to call on each range object.
ctx	Execution context.

This will iterate through the list of entries and call rangeUpdater on the RANGE part of each. Be careful: rangeUpdater must not change any part of the range which might affect the sorting of entries.

Remove unused entries from the front of the list.

Parameters

keys	List of keys that may still be in use. (Must be sorted.)
trimall	If true, then allow removing all elements in the container. Otherwise, stop when there's one left.

We examine the objects in the container, starting with the earliest one. If none of the keys in keys match the range for this object, then it is removed from the container. We stop when we either find an object with a range matching a key in keys or (if trimall is false) when there is only one object left.

The list keys MUST be sorted.

Removed objects are queued for deletion once all slots have been marked as quiescent.

Returns the number of objects that were removed.

Remove all entries in the container. Mostly for testing — should not normally be used.

Return the current number of elements in the map.

Test if the map is empty.

Return the current capacity of the map.

Return the number times an item was inserted into the map.

Return the maximum size of the map.

Return a range that can be used to iterate over the container.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Type of the mutex for this container.

Return the begin/last pointers.

Parameters

[in,out]

last

Current value of last.

Retrieve consistent values of the begin and last pointers. The last pointer should have already been fetched, and may be updated. Usage should be like this:

const_iterator last = m_last;
if (!last) return;  // Container empty.
const_iterator begin = getBegin (last);
if (!last) return;  // Container empty.

Consistently update both the begin and last pointers.

Parameters

begin	New begin pointer.
end	New end pointer.

Test to see if any keys within keys match r. r Range to test. @break keys List of keys to test. MUST be sorted.

Install a new implementation instance and make it visible.

Parameters

new_impl	The new instance.
new_begin	Begin pointer for the new instance.
new_end	End pointer for the new instance. (Usual STL meaning of end. If the instance is empty, then new_end should match new_begin.)
ctx	Execution context.

Extend the range of the last entry of the map.

Parameters

Lock	object.
extendedRange	New range to use for the last entry.
ctx	Execution context.

Implementation of extendLastRange; see there for details. Must be called with the lock held.

Updater object. This maintains ownership of the current implementation class and the older versions.

Comparison object.

Payload deleter object. Important: do not discard an object while it's still reachable from the m_begin / m_last range — update the pointers first. Otherwise, the object may be deleted while another thread is still referencing it: thread 1: Discard object. Sets grace mask for both slots. thread 2: Call quiescent(). Clears grace mask for 2. Retrieve the discarded object. thread 1: Adjust pointers. Call quiescent. The discarded object may be deleted at this point while thread 2 is still reading it.

Current version of the implementation class.

Pointers to the first and last elements of the container. m_last is not the usual end pointer; it points at the last element in the container. If the container is empty, then m_last will be null. If these are to both be updated together, it should be done in this order. First, m_begin should be set to null. This marks that there's an update in progress. Then m_last should be set, followed by m_begin. To read both pointers, we first fetch m_last. Then fetch m_begin. Then check that both m_begin is non-null and the previous value we fetched for last matches what's now in m_last. If either condition fails, then re-fetch both pointers.

Some basic statistics.

Mutex protecting the container.

Definition at line 210 of file ConcurrentRangeMap.h.

{
public:
  typedef RANGE key_type;
  typedef const T* mapped_type;
  typedef std::pair<RANGE, const T*> value_type;
  typedef const value_type& const_reference;
  typedef const value_type* const_pointer;
  typedef size_t size_type;
  typedef int difference_type;
  typedef COMPARE key_compare;
  typedef KEY key_query_type;
 
 
  typedef void delete_function (const T*);
 
 
  struct DeletePayload
  {
    DeletePayload (delete_function* delfcn)
      : m_delete (delfcn)
    {
    }
 
    template <class U>
    static void delfcn (const T* p)
    {
      delete reinterpret_cast<const U*>(p);
    }
    template <class U>
    DeletePayload (const std::default_delete<U>&)
    {
      m_delete = delfcn<U>;
    }
 
    void operator() (const T* p) const
    {
      m_delete (p);
    }
 
    delete_function* m_delete;
  };
 
 
  typedef std::unique_ptr<T, DeletePayload> payload_unique_ptr;
 
  typedef const value_type* const_iterator;
  typedef boost::iterator_range<const_iterator> const_iterator_range;
 
 
  class Impl
  {
  public:
    Impl (size_t capacity = 10);
 
 
    ~Impl() = default;
 
 
    value_type* data();
 
 
    size_t capacity() const;
 
 
  private:
    std::vector<value_type> m_data;
  };
 
  using Updater_t = UPDATER<Impl>;
  using IPayloadDeleter = CxxUtils::IRangeMapPayloadDeleter<T, typename Updater_t::Context_t>;
 
 
  ConcurrentRangeMap (Updater_t&& updater,
                      std::shared_ptr<IPayloadDeleter> payloadDeleter,
                      size_t capacity = 16,
                      const COMPARE& compare = COMPARE());
 
 
  ~ConcurrentRangeMap();
 
 
  IPayloadDeleter& deleter();
 
 
  const IPayloadDeleter& deleter() const;
 
 
  const_iterator find (const key_query_type& key) const;
 
 
  enum class EmplaceResult
  {
    SUCCESS,
 
    OVERLAP,
 
    DUPLICATE,
 
    // Existing range was extended to match the new range; new object
    // was deleted.
    EXTENDED
  };
 
 
  EmplaceResult emplace (const RANGE& range,
                         payload_unique_ptr ptr,
                         bool tryExtend = false,
                         const typename Updater_t::Context_t& ctx =
                           Updater_t::defaultContext());
 
 
  void erase (const key_query_type& key,
              const typename Updater_t::Context_t& ctx =
                Updater_t::defaultContext());
 
 
  int extendLastRange (const RANGE& newRange,
                       const typename Updater_t::Context_t& ctx =
                         Updater_t::defaultContext());
 
 
  void updateRanges (std::function<void (RANGE&)> rangeUpdater,
                     const typename Updater_t::Context_t& ctx =
                       Updater_t::defaultContext());
 
 
  size_t trim (const std::vector<key_query_type>& keys, bool trimall = false);
 
 
  void clear();
 
 
  size_t size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  size_t nInserts() const;
 
 
  size_t maxSize() const;
 
 
  const_iterator_range range() const;
 
 
  void quiescent (const typename Updater_t::Context_t& ctx =
                    Updater_t::defaultContext());
 
 
private:
  typedef std::mutex mutex_t;
  typedef std::lock_guard<mutex_t> lock_t;
 
 
  const_iterator getBegin (const_iterator& last) const;
 
 
  void updatePointers (value_type* new_begin, value_type* new_end);
 
  
  bool anyInRange (const key_type& r,
                   const std::vector<key_query_type>& keys) const;
 
 
  void installImpl (std::unique_ptr<Impl> new_impl,
                    value_type* new_begin,
                    value_type* new_end,
                    const typename Updater_t::Context_t& ctx);
 
  
  int extendImpl (lock_t& lock,
                  const RANGE& extendedRange,
                    const typename Updater_t::Context_t& ctx);
 
 
 
  Updater_t m_updater;
 
  COMPARE m_compare;
 
  std::shared_ptr<IPayloadDeleter> m_payloadDeleter;
 
  Impl* m_impl;
 
  std::atomic<value_type*> m_begin;
  std::atomic<value_type*> m_last;
 
  size_t m_nInserts;
  size_t m_maxSize;
 
  mutex_t m_mutex;
};

requires() [5/5]

template<class VALUE , template< class > class UPDATER>

CxxUtils::requires

(

detail::IsUpdater< UPDATER >

)

A set of pointers, allowing concurrent, lockless queries.

Hash map from strings to arbitrary objects allowing concurrent, lockless reads.

This class implements a set of pointers, allowing for concurrent access from many threads. Queries can proceed without taking out a lock, while insertions are serialized with each other. Thus, this is appropriate for sets which are read-mostly.

This is based on ConcurrentHashmapImpl.

Besides the pointer target type, this class is templated on an UPDATER class, which is used to manage the underlying memory. See IsUpdater.h for details. (AthenaKernel/RCUUpdater is a concrete version that should work in the context of Athena.)

This mostly supports the interface of std::unordered_set, with a few differences / omissions:

• No try_emplace.
• No insert methods with hints.
• No erase() methods.
• No operator==.
• Nothing dealing with the bucket/node interface or merge().

Performance: This is the result from running the test with –perf on my machine, with gcc 12.1.1:

ConcurrentPtrSet lookup: 1.225s wall, 1.220s user + 0.000s system = 1.220s CPU (99.6%) iterate: 0.646s wall, 0.640s user + 0.000s system = 0.640s CPU (99.0%) UnorderedSet lookup: 1.894s wall, 1.880s user + 0.000s system = 1.880s CPU (99.3%) iterate: 1.064s wall, 1.060s user + 0.000s system = 1.060s CPU (99.6%) concurrent_unordered_set lookup: 5.369s wall, 5.320s user + 0.000s system = 5.320s CPU (99.1%) iterate: 4.151s wall, 4.130s user + 0.000s system = 4.130s CPU (99.5%) ck_ht lookup: 2.034s wall, 2.020s user + 0.000s system = 2.020s CPU (99.3%) iterate: 1.500s wall, 1.500s user + 0.000s system = 1.500s CPU (100.0%)

The timing for the lookup test of UnorderedSet is probably overly-optimistic, since the test doesn't do any locking in that case.

This class implements a hash map from strings. The mapped type is arbitrary. It allows for concurrent access from many threads. Reads can proceed without taking out a lock, while writes are serialized with each other. Thus, this is appropriate for maps which are read-mostly.

This class includes non-const references that can be used to obtain non-const references to the mapped objects. Howeer, the mapped objects must themselves the thread-safe in order to safely modify them in a multithreaded context.

This is based on ConcurrentHashmapImpl.

Besides the key and mapped value types, this class is templated on an UPDATER class, which is used to manage the underlying memory. See IsUpdater.h for details. (AthenaKernel/RCUUpdater is a concrete version that should work in the context of Athena.)

This mostly supports the interface of std::unordered_map, with a few differences / omissions:

• Dereferencing the iterator returns a structure by value, not a reference.
• No try_emplace.
• No insert methods with hints.
• No clear / erase / overwrite. Those could be implemented if needed (but would require some extra complexity in the memory management).
• No operator==.
• Nothing dealing with the bucket/node interface or merge().

The mapped value can be given as any of:

• A value or const reference. In that case, it needs to be copy-constructable.
• A rvalue-reference. In that case, it needs to be movable.
• A unique_ptr to an instance.

I.e., any of these should work:

CxxUtils::ConcurrentToValMap<int, Payload> map;
const Payload p (1);
map.emplace ("key1", p);  // By value / const reference
map.emplace ("key2", Payload (2));  // By rvalue-reference.
                               // Could also move() an instance.
map.emplace ("key3", std::make_unique<Payload> (3));  // By unique_ptr.

The underlying uint->uint hash table.

Representation type in the underlying map.

Standard STL types.

Updater object.

Context type.

Type for external locking.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another set.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the set.

Test if the set is currently empty.

Return the current size (capacity) of the hash table.

Value type for iterators.

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire set.

Iterator at the start of the set.

Iterator at the end of the set.

Iterator at the start of the set.

Iterator at the end of the set.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the set.

Look up an element in the set.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Take a lock on the container.

Take a lock on the container. The lock can then be passed to insertion methods, allowing to factor out the locking inside loops. The lock will be released when the lock object is destroyed.

Add an element to the set.

Parameters

key	The key of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the set, with external locking.

Parameters

lock	The lock object returned from lock().
key	The key of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the set.

Parameters

p	The item to add.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

This is the same as emplace(). Use that for the case of external locking.

Insert a range of elements to the set.

Parameters

first	Start of the range.
last	End of the range.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Erase the table and change the capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

Erase the table (don't change the capacity).

Parameters

ctx	Execution context.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to a pointer.

Parameters

val	The underlying key value.

Convert a pointer to an underlying key value.

Parameters

p	The pointer.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert an entry in the table.

Parameters

key	The new item to add.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert an entry in the table, with external locking.

Parameters

lock	The lock object returned from lock().
key	The new item to add.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Hash functional for keys.

The key can be either a pointer or the representation type used by the underlying map.

Hash function from the underlying representation type.

Hash function from a pointer.

Hash functional.

Matching functional for keys.

Compare two keys (as the underlying representation type) for equality.

The underlying hash table.

The underlying uint->uint hash table.

Representation type in the underlying map.

Standard STL types.

Updater object.

Context type.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another map.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from a range of pairs.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the map.

Test if the map is currently empty.

Return the current size (capacity) of the hash table.

Value structures for iterators.

For a map from K to V, a STL-style iterator should dereference to a std::pair<const K, V>. However, we don't actually store an object like that anywhere. In order to be able to have STL-like iterators, we instead use a pair where the second element is a const reference to the mapped value. We will return this by value when we deference an iterator. (The compiler should be able to optimize out the redundant packing and unpacking of fields.)

Const iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Conversion from non-const iterator (for interoperability).

Parameters

other

The other iterator.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a iterator_value by value, we also need to override the reference type.

From this, we can get a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire map.

Return an iterator range covering the entire map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Iterator at the start of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the end of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

The mapped object must itself be thread-safe in order to make any changes to it through the returned iterator.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

This returns a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert a range of elements to the map.

Parameters

first	Start of the range.
last	End of the range.
ctx	Execution context.

The range should be a sequence of pairs where first is the string key and second is the integer value.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to a string pointer.

Parameters

val	The underlying key value.

Convert a string pointer to an underlying key value.

Parameters

s	The string pointer.

Convert an underlying mapped value a pointer to this type's mapped value.

Parameters

val	The underlying mapped value.

Convert this type's mapped value to an underlying mapped value.

Parameters

val	The mapped value.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert an entry in the table.

Parameters

key	The key of the new item to add.
val	The new mapped value to add.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Hash functional for keys.

The key can be either a std::string or the representation type used by the underlying map.

Hash function from the underlying representation type.

Hash function from a std::string.

Hash functional.

Matching functional for keys.

Compare two keys (as the underlying representation type) for equality.

The underlying hash table.

The underlying uint->uint hash table.

Representation type in the underlying map.

Standard STL types.

Updater object.

Context type.

Constructor.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from another map.

Parameters

updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

(Not really a copy constructor since we need to pass updater.)

Constructor from a range.

Parameters

f	Start iterator for the range.
l	End iterator for the range.
updater	Object used to manage memory (see comments at the start of the class).
capacity	The initial table capacity of the new table. (Will be rounded up to a power of two.)
ctx	Execution context.

Constructor from a range of pairs.

Copy / move / assign not supported.

Destructor.

Return the number of items currently in the map.

Test if the map is currently empty.

Return the current size (capacity) of the hash table.

Value structures for iterators.

For a map from K to V, a STL-style iterator should dereference to a std::pair<const K, V>. However, we don't actually store an object like that anywhere. In order to be able to have STL-like iterators, we instead use a pair where the second element is a const reference to the mapped value. We will return this by value when we deference an iterator. (The compiler should be able to optimize out the redundant packing and unpacking of fields.)

Const iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a const_iterator_value by value, we also need to override the reference type.

Constructor.

Parameters

it	Iterator of the underlying table.

Conversion from non-const iterator (for interoperability).

Parameters

other

The other iterator.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

Iterator class.

This uses boost::iterator_facade to define the methods required by an STL iterator in terms of the private methods below.

Since dereference() will be returning a iterator_value by value, we also need to override the reference type.

From this, we can get a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Constructor.

Parameters

it	Iterator of the underlying table.

Test if this iterator is valid.

This should be the same as testing for != end().

Required by iterator_facade.

iterator_facade requirement: Increment the iterator.

iterator_facade requirement: Decrement the iterator.

iterator_facade requirement: Equality test.

iterator_facade requirement: Equality test. (Interoperability.)

iterator_facade requirement: Dereference the iterator.

The iterator on the underlying table.

A range defined by two iterators.

Return an iterator range covering the entire map.

Return an iterator range covering the entire map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Iterator at the start of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the end of the map.

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Iterator at the start of the map.

Iterator at the end of the map.

Test if a key is in the container.

Parameters

key	The key to test.

Return the number of times a given key is in the container.

Parameters

key	The key to test.

Returns either 0 or 1, depending on whether or not the key is in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

Look up an element in the map.

Parameters

key	The element to find.

Returns either an iterator referencing the found element or end().

The mapped object must itself be thread-safe in order to make any changes to it through the returned iterator.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

Look up an element in the map.

Parameters

key	The element to find.

Returns the value associated with the key. Throws std::out_of_range if the key does not exist in the map.

This returns a non-const reference to the mapped object. The mapped object must be thread-safe itself in order to safely make any changes to it.

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

Return a range of iterators with entries matching key.

Parameters

key	The element to find.

As keys are unique in this container, this is either a single-element range, or both iterators are equal to end().

The mapped objects must themselves be thread-safe in order to make any changes to them through the returned iterators.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

key	The key of the new item to add.
val	The value of the new item to add.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Add an element to the map.

Parameters

p	The item to add. Should be a pair where first is the string key and second is the integer value.
ctx	Execution context.

This will not overwrite an existing entry. The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Insert a range of elements to the map.

Parameters

first	Start of the range.
last	End of the range.
ctx	Execution context.

The range should be a sequence of pairs where first is the string key and second is the integer value.

Increase the table capacity.

Parameters

capacity	The new table capacity.
ctx	Execution context.

No action will be taken if capacity is smaller than the current capacity.

Increase the table capacity.

Parameters

capacity

The new table capacity.

No action will be taken if capacity is smaller than the current capacity.

Called when this thread is no longer referencing anything from this container.

Parameters

ctx	Execution context.

Swap this container with another.

Parameters

other

The container with which to swap.

This will also call swap on the Updater object; hence, the Updater object must also support swap.

This operation is NOT thread-safe. No other threads may be accessing either container during this operation.

Access the Updater instance.

Convert an underlying key value to a string pointer.

Parameters

val	The underlying key value.

Convert a string pointer to an underlying key value.

Parameters

s	The string pointer.

Convert an underlying mapped value a pointer to this type's mapped value.

Parameters

val	The underlying mapped value.

Convert this type's mapped value to an underlying mapped value.

Parameters

val	The mapped value.

Do a lookup in the table.

Parameters

key	The key to look up.

Returns an iterator of the underlying map pointing at the found entry or end();

Insert an entry in the table.

Parameters

key	The key of the new item to add.
val	The new mapped value to add.
ctx	Execution context.

The first element in the returned pair is an iterator referencing the added item. The second is a flag that is true if a new element was added.

Hash functional for keys.

The key can be either a std::string or the representation type used by the underlying map.

Hash function from the underlying representation type.

Hash function from a std::string.

Hash functional.

Matching functional for keys.

Compare two keys (as the underlying representation type) for equality.

The underlying hash table.

Definition at line 74 of file ConcurrentPtrSet.h.

{
private:
  struct Hasher;
  struct Matcher;
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER, Hasher, Matcher>;
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
 
public:
  using key_type = VALUE*;
  using const_key_type = const VALUE*;
  using size_type = size_t;
  using Updater_t = typename Impl_t::Updater_t;
  using Context_t = typename Updater_t::Context_t;
  using Lock_t = typename Impl_t::Lock_t;
 
 
  ConcurrentPtrSet (Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentPtrSet (const ConcurrentPtrSet& other,
                    Updater_t&& updater,
                    size_t capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentPtrSet (InputIterator f,
                    InputIterator l,
                    Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentPtrSet (const ConcurrentPtrSet& other) = delete;
  ConcurrentPtrSet (ConcurrentPtrSet&& other) = delete;
  ConcurrentPtrSet& operator= (const ConcurrentPtrSet& other) = delete;
  ConcurrentPtrSet& operator= (ConcurrentPtrSet&& other) = delete;
 
 
  ~ConcurrentPtrSet();
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  using const_iterator_value = const key_type;
 
 
  class const_iterator
    : public boost::iterator_facade<const_iterator,
                                    const const_iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const const_iterator_value>
  {
  public:
    const_iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    key_type dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
 
 
  const_iterator_range range() const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (const const_key_type key) const;
 
 
  size_type count (const const_key_type key) const;
 
 
  const_iterator find (const const_key_type key) const;
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (const const_key_type key) const;
 
 
  Lock_t lock();
 
 
  std::pair<const_iterator, bool>
  emplace (const key_type key,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           const key_type key,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool> insert (const key_type p);
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last);
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void clear (size_t capacity,
              const Context_t& ctx = Updater_t::defaultContext());
 
 
  void clear (const Context_t& ctx = Updater_t::defaultContext());
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentPtrSet& other);
 
 
  Updater_t& updater();
 
 
private:
  static key_type keyAsPtr (val_t val);
 
 
  static val_t keyAsVal (const const_key_type p);
 
 
  typename Impl_t::const_iterator get (const const_key_type key) const;
 
 
  std::pair<const_iterator, bool>
  put (const key_type key,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       const key_type key,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  struct Hasher
  {
    size_t operator() (const val_t p) const;
    size_t operator() (const const_key_type p) const;
    std::hash<const_key_type> m_hash;
  };
 
 
  struct Matcher
  {
    bool operator() (const val_t a, const val_t b) const;
  };
 
 
  Impl_t m_impl;
};

reset()

template<class E >

constexpr std::enable_if_t<is_bitmask_v<E>, E&> CxxUtils::reset ( E &  lhs, E  rhs  )

constexpr

Convenience function to clear bits in a class enum bitmask.

Parameters

lhs	Target bitmask.
rhs	Bits to clear.

Same as lhs &= ~rhs.
This function is enabled only for enumerators that have used the ATH_BITMASK macro.

Definition at line 251 of file bitmask.h.

{
  lhs &= ~rhs;
  return lhs;
}

safeHexdump()

void CxxUtils::safeHexdump	(	std::ostream &	s,
		const void *	addr,
		size_t	n,
		size_t	offset = 0
	)

Make a hex dump of memory, protected against bad reads.

Parameters

s	Stream to which to write the output.
addr	Address at which to start dumping.
n	Number of byte to dump.
offset	Offset by which to shift the printed address (mostly for testing).

This function will skip dumping memory pages that are not readable. It may also start dumping slightly before the requested address, in order to start with an alignment of 16.

Definition at line 104 of file hexdump.cxx.

{
  const char* ptr = reinterpret_cast<const char*> (addr);
 
  // Adjust to start at width-byte boundary.
  size_t nadj = reinterpret_cast<uintptr_t>(ptr) % width;
  if (nadj > 0) {
    ptr -= nadj;
    n += nadj;
  }
 
  size_t pagesize = sysconf (_SC_PAGESIZE);
 
  procmaps m;
 
  // Print page by page.
  while (n > 0) {
    uintptr_t iptr = reinterpret_cast<uintptr_t>(ptr);
    size_t thispage = ((iptr + pagesize) & ~(pagesize-1)) - iptr;
    if (thispage > n) {
      thispage = n;
    }
    const procmaps::Entry* ent = m.getEntry (ptr);
    if (ent && ent->readable) {
      hexdump (s, ptr, thispage, offset);
    }
    else {
      boost::io::ios_all_saver saver (s);
      std::hex (s);
      s.fill ('0');
      s << std::setw(16) << reinterpret_cast<uintptr_t>(ptr) - offset
        << "  --- is not readable\n";
      if (ent) {
        thispage = std::max (ent->endAddress - iptr, thispage);
      }
    }
    ptr += thispage;
    n -= thispage;
  }
}

set()

template<class E >

constexpr std::enable_if_t<is_bitmask_v<E>, E&> CxxUtils::set ( E &  lhs, E  rhs  )

constexpr

Convenience function to set bits in a class enum bitmask.

Parameters

lhs	Target bitmask.
rhs	Bits to set.

Same as lhs |= rhs.
This function is enabled only for enumerators that have used the ATH_BITMASK macro.

Definition at line 232 of file bitmask.h.

{
  lhs |= rhs;
  return lhs;
}

set_unaligned()

template<class T >

void CxxUtils::set_unaligned	(	uint8_t *ATH_RESTRICT &	p,
		T	val
	)

Define templated versions of the above functions.

set_unaligned16()

void CxxUtils::set_unaligned16 ( uint8_t *ATH_RESTRICT &  p, uint16_t  val  )

inline

Write a 2-byte little-endian value to a possibly unaligned pointer.

Parameters

p	Pointer to which to write. Advanced to the next value.
val	Value to write.

Writes a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 64 of file set_unaligned.h.

{
  uint16_t tmp = htole16 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}

set_unaligned32()

void CxxUtils::set_unaligned32 ( uint8_t *ATH_RESTRICT &  p, uint32_t  val  )

inline

Write a 4-byte little-endian value to a possibly unaligned pointer.

Parameters

p	Pointer to which to write. Advanced to the next value.
val	Value to write.

Writes a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 84 of file set_unaligned.h.

{
  uint32_t tmp = htole32 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}

set_unaligned64()

void CxxUtils::set_unaligned64 ( uint8_t *ATH_RESTRICT &  p, uint64_t  val  )

inline

Write an 8-byte little-endian value to a possibly unaligned pointer.

Parameters

p	Pointer to which to write. Advanced to the next value.
val	Value to write.

Writes a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 104 of file set_unaligned.h.

{
  uint64_t tmp = htole64 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}

set_unaligned< double >()

template<>

void CxxUtils::set_unaligned< double > ( uint8_t *ATH_RESTRICT &  p, double  f  )

inline

Definition at line 197 of file set_unaligned.h.

{
  set_unaligned_double (p, f);
}

set_unaligned< float >()

template<>

void CxxUtils::set_unaligned< float > ( uint8_t *ATH_RESTRICT &  p, float  f  )

inline

Definition at line 189 of file set_unaligned.h.

{
  set_unaligned_float (p, f);
}

set_unaligned< int16_t >()

template<>

void CxxUtils::set_unaligned< int16_t > ( uint8_t *ATH_RESTRICT &  p, int16_t  val  )

inline

Definition at line 213 of file set_unaligned.h.

{
  set_unaligned<uint16_t> (p, std::bit_cast<uint16_t> (val));
}

set_unaligned< int32_t >()

template<>

void CxxUtils::set_unaligned< int32_t > ( uint8_t *ATH_RESTRICT &  p, int32_t  val  )

inline

Definition at line 221 of file set_unaligned.h.

{
  set_unaligned<uint32_t> (p, std::bit_cast<uint32_t> (val));
}

set_unaligned< int64_t >()

template<>

void CxxUtils::set_unaligned< int64_t > ( uint8_t *ATH_RESTRICT &  p, int64_t  val  )

inline

Definition at line 229 of file set_unaligned.h.

{
  set_unaligned<uint64_t> (p, std::bit_cast<uint64_t> (val));
}

set_unaligned< int8_t >()

template<>

void CxxUtils::set_unaligned< int8_t > ( uint8_t *ATH_RESTRICT &  p, int8_t  val  )

inline

Definition at line 205 of file set_unaligned.h.

{
  set_unaligned<uint8_t> (p, std::bit_cast<uint8_t> (val));
}

set_unaligned< uint16_t >()

template<>

void CxxUtils::set_unaligned< uint16_t > ( uint8_t *ATH_RESTRICT &  p, uint16_t  val  )

inline

Definition at line 165 of file set_unaligned.h.

{
  set_unaligned16 (p, val);
}

set_unaligned< uint32_t >()

template<>

void CxxUtils::set_unaligned< uint32_t > ( uint8_t *ATH_RESTRICT &  p, uint32_t  val  )

inline

Definition at line 173 of file set_unaligned.h.

{
  set_unaligned32 (p, val);
}

set_unaligned< uint64_t >()

template<>

void CxxUtils::set_unaligned< uint64_t > ( uint8_t *ATH_RESTRICT &  p, uint64_t  val  )

inline

Definition at line 181 of file set_unaligned.h.

{
  set_unaligned64 (p, val);
}

set_unaligned< uint8_t >()

template<>

void CxxUtils::set_unaligned< uint8_t > ( uint8_t *ATH_RESTRICT &  p, uint8_t  val  )

inline

Definition at line 157 of file set_unaligned.h.

{
  *p++ = val;
}

set_unaligned_double()

void CxxUtils::set_unaligned_double ( uint8_t *ATH_RESTRICT &  p, double  val  )

inline

Write a little-endian double value to a possibly unaligned pointer.

Parameters

p	Pointer to which to write. Advanced to the next value.
val	Value to write.

Writes a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 142 of file set_unaligned.h.

{
  set_unaligned64 (p, std::bit_cast<uint64_t> (val));
}

set_unaligned_float()

void CxxUtils::set_unaligned_float ( uint8_t *ATH_RESTRICT &  p, float  val  )

inline

Write a little-endian float value to a possibly unaligned pointer.

Parameters

p	Pointer to which to write. Advanced to the next value.
val	Value to write.

Writes a little-endian value, regardless of the host byte ordering, and advances the pointer. Should not rely on undefined behavior, regardless of the alignment of p.

If used in a loop, you'll get better code with a restricted pointer.

Definition at line 124 of file set_unaligned.h.

{
  set_unaligned32 (p, std::bit_cast<uint32_t> (val));
}

span() [1/2]

template<class T >

CxxUtils::span	(	T *	beg,
		T *	end
	)		-> span< T >

span() [2/2]

template<class T >

CxxUtils::span	(	T *	ptr,
		std::size_t	sz
	)		-> span< T >

A couple needed deduction guides.

stall()

void CxxUtils::stall ( )

inline

Emit stall instruction for use in a spin loop.

For best performance of a spin loop (as used for a spinlock or other MT consistency operations), Intel recommends adding a ‘pause’ instruction within the loop on x86(_64) targets. This function provides a portable way of doing this.

Currently a no-op for anything other than x86(_64) + arm. Support for other architectures can be added if it is useful.

Definition at line 37 of file stall.h.

{
#if defined(__i386__) || defined(__x86_64__)
  _mm_pause();
#elif defined(__aarch64__) && defined(__GNUC__)
  asm volatile("yield" ::: "memory");
#endif
}

strformat()

std::string CxxUtils::strformat	(	const char *	fmt,
			...
	)

return a std::string according to a format fmt and varargs

Definition at line 49 of file StrFormat.cxx.

{
  char *buf = NULL;
  int nbytes = -1;
 
  va_list ap;
  va_start(ap, fmt); /* Initialize the va_list */
 
  nbytes = vasprintf(&buf, fmt, ap);
  va_end(ap); /* Cleanup the va_list */
 
  if (nbytes < 0) {
    /*buf is undefined when allocation failed
     * see: http://linux.die.net/man/3/asprintf
     */
    // free(buf); 
    throw std::runtime_error("problem while calling vasprintf");
  }
 
  CharLiberator guard(buf);
 
  // help compiler to apply RVO
  return std::string(buf);
}

test()

template<class E >

constexpr std::enable_if_t<is_bitmask_v<E>, bool> CxxUtils::test ( E  lhs, E  rhs  )

constexpr

Convenience function to test bits in a class enum bitmask.

Parameters

lhs	Target bitmask.
rhs	Bits to test.

Same as (lhs & rhs) != 0. This function is enabled only for enumerators that have used the ATH_BITMASK macro.

Definition at line 270 of file bitmask.h.

{
  typedef std::underlying_type_t<E>underlying;
  return static_cast<underlying> (lhs & rhs) != 0;
}

to()

template<class CONT , class RANGE >

CONT CxxUtils::to

(

RANGE &&

r

)

Definition at line 39 of file ranges.h.

{
  return CONT (std::ranges::begin (r), std::ranges::end (r));
}

tokenize()

std::vector< std::string > CxxUtils::tokenize	(	const std::string &	the_str,
		std::string_view	delimiters
	)

Splits the string into smaller substrings.

Definition at line 15 of file Control/CxxUtils/Root/StringUtils.cxx.

                                                                 {
                                    
        std::vector<std::string> tokens{};
        // Skip delimiters at beginning.
        std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
        // Find first "non-delimiter".
        std::string::size_type pos = str.find_first_of(delimiters, lastPos);
    
        while (std::string::npos != pos || std::string::npos != lastPos) {
            // Found a token, add it to the vector.
            tokens.push_back(str.substr(lastPos, pos - lastPos));
            // Skip delimiters.  Note the "not_of"
            lastPos = str.find_first_not_of(delimiters, pos);
            // Find next "non-delimiter"
            pos = str.find_first_of(delimiters, lastPos);
        }
        return tokens;
    }

tokenizeDouble()

std::vector< double > CxxUtils::tokenizeDouble	(	const std::string &	the_str,
		std::string_view	delimiter
	)

Definition at line 34 of file Control/CxxUtils/Root/StringUtils.cxx.

                                                                {
        const std::vector<std::string> strTokens = tokenize(the_str, delimiter);
        std::vector<double> toReturn{};
        std::transform(strTokens.begin(), strTokens.end(), std::back_inserter(toReturn), 
                    [](const std::string& token){
                        return atof(token);
                    });
        return toReturn;
    }

tokenizeInt()

std::vector< int > CxxUtils::tokenizeInt	(	const std::string &	the_str,
		std::string_view	delimiter
	)

Definition at line 55 of file Control/CxxUtils/Root/StringUtils.cxx.

                                                           {
        const std::vector<std::string> strTokens = tokenize(the_str, delimiter);
        std::vector<int> toReturn{};
        std::transform(strTokens.begin(), strTokens.end(), std::back_inserter(toReturn), 
                        [](const std::string& token){
                            return atoi(token);
                        });
        return toReturn;
    }

ubsan_suppress()

void CxxUtils::ubsan_suppress

(

void(*)()

func

)

Helper for suppressing ubsan warnings.

Parameters

func	Function to call (may be a lambda).

If ubsan is running, temporarily redirect stderr to /dev/null. Then call func.

For example, we sometimes get a bogus ubsan warning from cling initialization. This can be suppressed by adding something like:

CxxUtils::ubsan_suppress ([]() { TInterpreter::Instance(); });

Definition at line 69 of file ubsan_suppress.cxx.

{
  if (dlsym (RTLD_DEFAULT, "__ubsan_handle_add_overflow") != NULL)
  {
    RedirStderr redir;
    func();
  }
  else {
    func();
  }
}

vall()

template<typename VEC >

ATH_ALWAYS_INLINE bool CxxUtils::vall

(

const VEC &

mask

)

Definition at line 402 of file vec.h.

                     {
  static_assert(std::is_integral<vec_type_t<VEC>>::value,
                "vec elements must be of integral type. Aka vec must be "
                "compatible with a mask");
  VEC alltrue;
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  // fallback compares to 0 when false
  // and 1 when is true
  vbroadcast(alltrue, vec_type_t<VEC>{1});
  return std::memcmp(mask.m_arr, alltrue.m_arr, sizeof(VEC)) == 0;
#else
  // For the gnu vector extensions
  // Vectors are compared element-wise producing 0 when comparison is false
  // and -1 (constant of the appropriate type where all bits are set) otherwise.
  vbroadcast(alltrue, vec_type_t<VEC>{-1});
  return std::memcmp(&mask, &alltrue, sizeof(VEC)) == 0;
#endif
}

vany()

template<typename VEC >

ATH_ALWAYS_INLINE bool CxxUtils::vany

(

const VEC &

mask

)

Definition at line 362 of file vec.h.

                     {
  static_assert(std::is_integral<vec_type_t<VEC>>::value,
                "vec elements must be of integral type. Aka vec must be "
                "compatible with a mask");
  VEC zero;
  vbroadcast(zero,vec_type_t<VEC>{0});
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  return std::memcmp(mask.m_arr, zero.m_arr, sizeof(VEC)) != 0;
#else
  return std::memcmp(&mask, &zero, sizeof(VEC)) != 0;
#endif
}

vbroadcast()

template<typename VEC , typename T >

ATH_ALWAYS_INLINE void CxxUtils::vbroadcast	(	VEC &	v,
		T	x
	)

Copy a scalar to each element of a vectorized type.

Definition at line 251 of file vec.h.

{
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  constexpr size_t N = CxxUtils::vec_size<VEC>();
  for (size_t i = 0; i < N; ++i) {
    v[i] = x;
  }
#else
  // using  - to avoid sign conversions.
  v = x - VEC{ 0 };
#endif
}

vconvert()

template<typename VEC1 , typename VEC2 >

ATH_ALWAYS_INLINE void CxxUtils::vconvert	(	VEC1 &	dst,
		const VEC2 &	src
	)

performs dst is the result of a static cast of each element of src

Definition at line 428 of file vec.h.

{
  static_assert((vec_size<VEC1>() == vec_size<VEC2>()),
                "vconvert dst and src have different number of elements");
 
#if !HAVE_CONVERT_VECTOR || WANT_VECTOR_FALLBACK
  typedef vec_type_t<VEC1> ELT;
  constexpr size_t N = vec_size<VEC1>();
  for (size_t i = 0; i < N; ++i) {
    dst[i] = static_cast<ELT>(src[i]);
  }
#else
  dst = __builtin_convertvector(src, VEC1);
#endif
}

vec_size() [1/2]

template<class VEC >

constexpr ATH_ALWAYS_INLINE size_t CxxUtils::vec_size ( )

constexpr

Return the number of elements in a vectorized type.

Definition at line 227 of file vec.h.

{
  typedef vec_type_t<VEC> ELT;
  return sizeof(VEC) / sizeof(ELT);
}

vec_size() [2/2]

template<class VEC >

constexpr ATH_ALWAYS_INLINE size_t CxxUtils::vec_size ( const VEC &  )

constexpr

Return the number of elements in a vectorized type.

Definition at line 239 of file vec.h.

{
  typedef vec_type_t<VEC> ELT;
  return sizeof(VEC) / sizeof(ELT);
}

vload()

template<typename VEC >

ATH_ALWAYS_INLINE void CxxUtils::vload	(	VEC &	dst,
		vec_type_t< VEC > const *	src
	)

Definition at line 272 of file vec.h.

{
 
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  std::memcpy(dst.m_arr, src, sizeof(VEC));
#else
  std::memcpy(&dst, src, sizeof(VEC));
#endif
}

vmax()

template<typename VEC >

ATH_ALWAYS_INLINE void CxxUtils::vmax	(	VEC &	dst,
		const VEC &	a,
		const VEC &	b
	)

Definition at line 343 of file vec.h.

{
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  constexpr size_t N = vec_size<VEC>();
  for (size_t i = 0; i < N; ++i) {
    dst[i] = a[i] > b[i] ? a[i] : b[i];
  }
#else
  dst = a > b ? a : b;
#endif
}

vmin()

template<typename VEC >

ATH_ALWAYS_INLINE void CxxUtils::vmin	(	VEC &	dst,
		const VEC &	a,
		const VEC &	b
	)

Definition at line 324 of file vec.h.

{
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  constexpr size_t N = vec_size<VEC>();
  for (size_t i = 0; i < N; ++i) {
    dst[i] = a[i] < b[i] ? a[i] : b[i];
  }
#else
  dst = a < b ? a : b;
#endif
}

vnone()

template<typename VEC >

ATH_ALWAYS_INLINE bool CxxUtils::vnone

(

const VEC &

mask

)

Definition at line 382 of file vec.h.

                      {
  static_assert(std::is_integral<vec_type_t<VEC>>::value,
                "vec elements must be of integral type. Aka vec must be "
                "compatible with a mask");
  VEC zero;
  vbroadcast(zero,vec_type_t<VEC>{0});
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  return std::memcmp(mask.m_arr, zero.m_arr, sizeof(VEC)) == 0;
#else
  return std::memcmp(&mask, &zero, sizeof(VEC)) == 0;
#endif
}

vpermute()

template<size_t... Indices, typename VEC , typename VEC1 >

ATH_ALWAYS_INLINE void CxxUtils::vpermute	(	VEC1 &	dst,
		const VEC &	src
	)

vpermute function.

move any element of a vector src into any or multiple position inside dst.

Definition at line 451 of file vec.h.

{
 
  static_assert((sizeof...(Indices) == vec_size<VEC1>()),
                "vpermute number of indices different than return vector size");
  static_assert(std::is_same<vec_type_t<VEC>, vec_type_t<VEC1>>::value,
                "vpermute type of input and output vector elements differ");
  static_assert(vecDetail::bool_pack_helper::all_true<(
                    Indices >= 0 && Indices < vec_size<VEC>())...>::value,
                "vpermute value of a mask index is outside the allowed range");
 
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  dst = VEC1{ src[Indices]... };
#else
  dst = __builtin_shufflevector(src, src, Indices...);
#endif
}

vpermute2()

template<size_t... Indices, typename VEC , typename VEC1 >

ATH_ALWAYS_INLINE void CxxUtils::vpermute2	(	VEC1 &	dst,
		const VEC &	src1,
		const VEC &	src2
	)

vpermute2 function.

move any element of the vectors src1, src2 into any or multiple position inside dst.

Definition at line 476 of file vec.h.

{
  static_assert(
      (sizeof...(Indices) == vec_size<VEC1>()),
      "vpermute2 number of indices different than return vector size");
  static_assert(std::is_same<vec_type_t<VEC>, vec_type_t<VEC1>>::value,
                "vpermute2 type of input and output vector elements differ");
  constexpr size_t N = vec_size<VEC>();
  static_assert(vecDetail::bool_pack_helper::all_true<(
                    Indices >= 0 && Indices < 2 * N)...>::value,
                "vpermute2 value of a mask index is outside the allowed range");
 
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  VEC1 tmp;
  size_t pos{0};
  for (auto index: { Indices... }) {
    if (index < N) {
      tmp[pos] = src1[index];
    } else {
      tmp[pos] = src2[index - N];
    }
    ++pos;
  }
  dst = tmp;
#else
  dst = __builtin_shufflevector(src1, src2, Indices...);
#endif
}

vselect()

template<typename VEC >

ATH_ALWAYS_INLINE void CxxUtils::vselect	(	VEC &	dst,
		const VEC &	a,
		const VEC &	b,
		const vec_mask_type_t< VEC > &	mask
	)

Definition at line 306 of file vec.h.

                                                                                     {
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  constexpr size_t N = vec_size<VEC>();
  for (size_t i = 0; i < N; ++i) {
    dst[i] = mask[i] ? a[i] : b[i];
  }
#else
  dst = mask ? a : b;
#endif
}

vstore()

template<typename VEC >

ATH_ALWAYS_INLINE void CxxUtils::vstore	(	vec_type_t< VEC > *	dst,
		const VEC &	src
	)

Definition at line 290 of file vec.h.

{
#if !HAVE_VECTOR_SIZE_ATTRIBUTE || WANT_VECTOR_FALLBACK
  std::memcpy(dst, src.m_arr, sizeof(VEC));
#else
  std::memcpy(dst, &src, sizeof(VEC));
#endif
}

wrapToPi()

template<typename T >

T CxxUtils::wrapToPi ( T  phi )

inline

Wrap angle in radians to [-pi, pi].

Odd positive (negative) multiples of pi map to (-)pi.

Definition at line 24 of file phihelper.h.

  {
    static_assert(std::is_floating_point<T>::value);
 
    constexpr auto PI = static_cast<T>(M_PI);
    // For large values this is faster:
    if (phi < -100 || phi > 100) {
      return std::remainder(phi, 2 * PI);
    }
    while (phi > PI) phi -= 2 * PI;
    while (phi < -PI) phi += 2 * PI;
    return phi;
  }

Variable Documentation

defaultCRCTable

const CRCTable CxxUtils::defaultCRCTable(0xad93d23594c935a9)

dynamic_extent

constexpr size_t CxxUtils::dynamic_extent = static_cast<size_t>(-1)

inlineconstexpr

Used to specify a subrange of indefinite size in subspan().

Definition at line 29 of file span.h.

FromArrayrep

template<class T >

concept CxxUtils::FromArrayrep

Initial value:

=
  requires (T t, const CxxUtils::Arrayrep& rep)
  {
    { CxxUtils::fromArrayrep (rep, t) };
  }

Concept testing whether a type may be used with FromArrayrep.

Definition at line 820 of file Control/CxxUtils/CxxUtils/Array.h.

InputRangeOverT

template<class RANGE , class T >

concept CxxUtils::InputRangeOverT

Initial value:

=
  std::ranges::input_range<RANGE> &&
  std::convertible_to<std::ranges::range_value_t<RANGE>, T>

Concept for an input range over a given type.

Definition at line 27 of file ranges.h.

valid_span_type_v

template<class T , class U >

constexpr bool CxxUtils::valid_span_type_v = std::is_convertible_v<U(*)[], T(*)[]>

inlineconstexpr

Is U* a valid type to use to initialize a span<T>? No more than const-conversion.

Same logic as used in libstdc++.

Definition at line 36 of file span.h.