CxxUtils Namespace Reference

Namespaces
namespace	detail
namespace	fpcompare
namespace	fpcompare_fn
namespace	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	Arrayrep
	Representation class for Array's. 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	ConcurrentMap
	Hash map from integers/pointers allowing concurrent, lockless reads. More...
class	ConcurrentPtrSet
	A set of pointers, allowing concurrent, lockless queries. More...
class	ConcurrentRangeMap
	Map from range to payload object, allowing concurrent, lockless reads. More...
class	ConcurrentStrMap
	Hash map from strings allowing concurrent, lockless reads. More...
class	ConcurrentStrToValMap
	Hash map from strings to arbitrary objects allowing concurrent, lockless reads. More...
class	ConcurrentToValMap
	Hash map from pointers/integers to arbitrary objects allowing concurrent, lockless reads. 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	iterator_range
	Simple range from a pair of iterators. 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	RefCountedPtr
	Simple smart pointer for Gaudi-style refcounted objects. More...
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.
template<class T>
using	vec_aligned_vector = aligned_vector<T, 64>
	A std::vector with alignment sufficient for any vector instructions on this platform.
template<class T>
using	CachedUniquePtr = CachedUniquePtrT<const T>
template<std::ranges::input_range SPAN, class XFORM>
using	transform_view_with_at
	Helper to add at() methods to a transform_view.
template<typename T, size_t N>
using	vec = typename vecDetail::vec_typedef<T,N>::type
	Define a nice alias for the vectorized type.
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.
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.
template<typename T, size_t N>
using	ivec = vec_fb<typename boost::int_t<sizeof(T) * 8>::exact, N>
typedef float	Arrayelt
	The type of an element of an Array.

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.
template<unsigned int N>
void	fromArrayrep (const CaloRec::Arrayrep &rep, CxxUtils::Array< N > &x)
	Helper to convert from an @x Arrayrep to an Array.
template<class T>
const T *	as_const_ptr (const T *p)
	Helper for getting a const version of a pointer.
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.
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.
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.
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.
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.
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.
template<std::integral T>
constexpr T	byteswap (T value) noexcept
	Reverse the bytes in n.
template<typename T>
bool	close_to_zero (T value, T eps=std::numeric_limits< T >::epsilon())
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.
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.
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.
template<class InputRange, class OutputRange>
auto	copy_bounded (const InputRange &input, OutputRange &output) -> decltype(std::begin(output))
	Copy a range with bounds restriction.
template<class InputRange, class OutputRange>
auto	copy_bounded (const InputRange &input, OutputRange &&output) -> decltype(std::begin(output))
	Copy a range with bounds restriction.
void	deleteCRCTable (CxxUtils::CRCTable *table)
	Delete a CRCTable object.
std::unique_ptr< CRCTable >	makeCRCTable (uint64_t p, uint64_t initial=0xffffffffffffffff)
	Initialize CRC tables and constants.
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.
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.
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.
uint64_t	crc64 (const CRCTable &table, const char *data, size_t data_len)
	Find the CRC-64 of a string,.
uint64_t	crc64 (const char *data, size_t data_len)
	Find the CRC-64 of a string, with the default CRC.
uint64_t	crc64 (const std::string &s)
	Find the CRC-64 of a string, using the default polynomial.
uint64_t	crc64addint (uint64_t crc, uint64_t x)
	Extend a previously-calculated CRC to include an int.
std::string	crc64format (uint64_t crc)
	Format a CRC-64 as a string.
std::string	crc64digest (const std::string &str)
	Return a CRC-64 digest of a string.
void	exctrace (const std::exception &e, IOFD fd=IOFD_INVALID)
	Print out information for the last exception.
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.
uint32_t	get_unaligned32 (const uint8_t *ATH_RESTRICT &p)
	Read a 4-byte little-endian value from a possibly unaligned pointer.
uint64_t	get_unaligned64 (const uint8_t *ATH_RESTRICT &p)
	Read an 8-byte little-endian value from a possibly unaligned pointer.
float	get_unaligned_float (const uint8_t *ATH_RESTRICT &p)
	Read a little-endian float value from a possibly unaligned pointer.
double	get_unaligned_double (const uint8_t *ATH_RESTRICT &p)
	Read a little-endian double value from a possibly unaligned pointer.
template<class T>
T	get_unaligned (const uint8_t *ATH_RESTRICT &p)
	Define templated versions of the above functions.
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.
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.
template<class RANGE, class FUNC>
auto	min_transformed_element (RANGE &&r, FUNC &&f)
	Find the minimum transformed element in a range.
template<class RANGE, class FUNC>
auto	max_transformed_element (RANGE &&r, FUNC &&f)
	Find the maximum transformed element in a range.
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.
template<class T>
constexpr T	ones (unsigned int n)
	Return a bit mask with the lower n bits set.
template<typename T>
T	wrapToPi (T phi)
	Wrap angle in radians to [-pi, pi].
template<typename T>
T	deltaPhi (T phiA, T phiB)
	Return difference phiA - phiB in range [-pi, pi].
template<typename T>
T	phiMean (T phiA, T phiB)
	Calculate average of two angles.
template<typename T>
T	phiBisect (T phiA, T phiB)
	Bisect (average) the angle spanned by phiA and phiB.
void	prefetchOne (const void *address)
	Generic prefetch method.
template<size_t N>
void	prefetchN (const void *ptr)
	Prefetch an N-byte block of memory.
template<typename T>
void	prefetchObj (const T *ptr)
	Generic prefetch of the object of specific types (sizes).
template<typename Iter>
void	prefetchNext (Iter iter, Iter endIter)
	Prefetch next object in sequence.
template<typename Iter>
void	prefetchTwo (Iter iter, Iter endIter)
	Prefetch two objects.
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.
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.
void	set_unaligned32 (uint8_t *ATH_RESTRICT &p, uint32_t val)
	Write a 4-byte little-endian value to a possibly unaligned pointer.
void	set_unaligned64 (uint8_t *ATH_RESTRICT &p, uint64_t val)
	Write an 8-byte little-endian value to a possibly unaligned pointer.
void	set_unaligned_float (uint8_t *ATH_RESTRICT &p, float val)
	Write a little-endian float value to a possibly unaligned pointer.
void	set_unaligned_double (uint8_t *ATH_RESTRICT &p, double val)
	Write a little-endian double value to a possibly unaligned pointer.
template<class T>
void	set_unaligned (uint8_t *ATH_RESTRICT &p, T val)
	Define templated versions of the above functions.
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.
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.
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.
std::string	strformat (const char *fmt,...)
	return a std::string according to a format fmt and varargs
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.
double	atof (std::string_view str)
	Converts a string into a double / float.
std::string_view	eraseWhiteSpaces (std::string_view str)
	Removes all trailing and starting whitespaces from a string.
std::vector< std::string >	tokenize (const std::string &the_str, std::string_view delimiters)
	Splits the string into smaller substrings.
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	throw_out_of_range (const std::string &what, size_t index, size_t size, const void *obj)
	Throw an out_of_range exception.
void	throw_out_of_range (const char *what, size_t index, size_t size, const void *obj)
	Throw an out_of_range exception.
void	ubsan_suppress (void(*func)())
	Helper for suppressing ubsan warnings.
template<class VEC>
ATH_ALWAYS_INLINE constexpr size_t	vec_size ()
	Return the number of elements in a vectorized type.
template<class VEC>
ATH_ALWAYS_INLINE constexpr size_t	vec_size (const VEC &)
	Return the number of elements in a vectorized type.
template<typename VEC, typename T>
ATH_ALWAYS_INLINE void	vbroadcast (VEC &v, T x)
	Copy a scalar to each element of a vectorized type.
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
template<size_t... Indices, typename VEC, typename VEC1>
ATH_ALWAYS_INLINE void	vpermute (VEC1 &dst, const VEC &src)
	vpermute function.
template<size_t... Indices, typename VEC, typename VEC1>
ATH_ALWAYS_INLINE void	vpermute2 (VEC1 &dst, const VEC &src1, const VEC &src2)
	vpermute2 function.
template<typename T, size_t N>
ivec< T, N >	operator! (const vec_fb< T, N > &a)
	Negation.
template<typename T, size_t N>
ivec< T, N >	operator&& (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 && V2.
template<typename T, size_t N, class U>
ivec< T, N >	operator&& (U a, const vec_fb< T, N > &b)
	S && V.
template<typename T, size_t N, class U>
ivec< T, N >	operator&& (const vec_fb< T, N > &a, U b)
	V && S.
template<typename T, size_t N>
ivec< T, N >	operator|| (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 || V2.
void *	xmalloc (size_t size)
	Trapping version of malloc.
std::string	clean_allocator (std::string f)
	Clean ‘allocator’ template arguments from the function f.
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
constexpr size_t	dynamic_extent = static_cast<size_t>(-1)
	Used to specify a subrange of indefinite size in subspan().
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>?
const CRCTable	defaultCRCTable (0xad93d23594c935a9)

Typedef Documentation

aligned_vector

template<class T, size_t Alignment = 1>

using CxxUtils::aligned_vector = 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.

Arrayelt

typedef float CaloRec::Arrayelt

The type of an element of an Array.

Definition at line 26 of file Control/CxxUtils/CxxUtils/Arrayrep.h.

CachedUniquePtr

template<class T>

using CxxUtils::CachedUniquePtr = CachedUniquePtrT<const T>

Definition at line 114 of file CachedUniquePtr.h.

ivec

template<typename T, size_t N>

using CxxUtils::ivec = 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

Initial value:

 
  range_with_at<std::ranges::transform_view<SPAN, XFORM> >

Helper to add at() methods to a transform_view.

Definition at line 58 of file range_with_at.h.

vec

template<typename T, size_t N>

using CxxUtils::vec = 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 = 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 = 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 = 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 67 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 65 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(); }

byteswap()

template<std::integral T>

T CxxUtils::byteswap ( T value )

constexprnoexcept

Reverse the bytes in n.

Copied from the example implementation given in https://en.cppreference.com/w/cpp/numeric/byteswap

Definition at line 42 of file byteswap.h.

{
    static_assert(std::has_unique_object_representations_v<T>, 
                  "T may not have padding bits");
    auto value_representation = std::bit_cast<std::array<std::byte, sizeof(T)>>(value);
    std::ranges::reverse(value_representation);
    return std::bit_cast<T>(value_representation);
}

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;
}

close_to_zero()

template<typename T>

bool CxxUtils::close_to_zero	(	T	value,
		T	eps = std::numeric_limits<T>::epsilon() )

Examples

/build/atnight/localbuilds/nightlies/main--Doxygen/athena/Control/CxxUtils/CxxUtils/close_to_zero.h.

Definition at line 48 of file close_to_zero.h.

                                                                     {
    if constexpr (std::is_integral_v<T>) {
      // For integers, only exact zero is invalid
      return value == 0;
    } else if constexpr (std::is_floating_point_v<T>) {
      return std::abs(value) < eps;
    } else {
      static_assert(std::is_arithmetic_v<T>, "close_to_zero: Only arithmetic types supported");
      return false;
    }
  }

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 71 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 69 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 = *reinterpret_cast<const 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 = *reinterpret_cast<const 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 = reinterpret_cast<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 ^= (reinterpret_cast<unsigned const char*>(data))[2] << 16;
  // FALLTHROUGH
  case 2: h2 ^= (reinterpret_cast<unsigned const char*>(data))[1] << 8;
  // FALLTHROUGH
  case 1: h2 ^= (reinterpret_cast<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 = *reinterpret_cast<const 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 = *reinterpret_cast<const 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>

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);
    }
  }
}

reset()

template<class E>

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;
  }
 
  long pagesize_ret = sysconf (_SC_PAGESIZE);
  if (pagesize_ret < 0 || pagesize_ret >= 1024*1024*1024) {
    std::abort();
  }
  size_t pagesize = pagesize_ret;
  
 
  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>

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>

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;
}

throw_out_of_range() [1/2]

void CxxUtils::throw_out_of_range	(	const char *	what,
		size_t	index,
		size_t	size,
		const void *	obj )

Throw an out_of_range exception.

Parameters

what	Description of the error.
index	The index that was out of range.
size	The size of the container.
obj	Pointer to the container (or other relevant object).

Definition at line 43 of file throw_out_of_range.cxx.

{
  throw_out_of_range (std::string(what), index, size, obj);
}

throw_out_of_range() [2/2]

void CxxUtils::throw_out_of_range	(	const std::string &	what,
		size_t	index,
		size_t	size,
		const void *	obj )

Throw an out_of_range exception.

Parameters

what	Description of the error.
index	The index that was out of range.
size	The size of the container.
obj	Pointer to the container (or other relevant object).

Definition at line 27 of file throw_out_of_range.cxx.

{
  throw std::out_of_range (std::format
    ("CxxUtils::throw_out_of_range {} requested index {} >= {} for object at {}",
     what, index, size, obj));
};

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>

ATH_ALWAYS_INLINE constexpr 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>

ATH_ALWAYS_INLINE constexpr 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;
  }

xmalloc()

void * CxxUtils::xmalloc

(

size_t

size

)

Trapping version of malloc.

Parameters

size	Number of bytes to allocate.

Calls malloc. Throws a std::bad_alloc exception on failure.

If you're writing new code, you probably don't want to use this! Use make_unique/new or STL containers instead. This is intended for compatiblilty with existing code requiring malloc/free.

Definition at line 31 of file xmalloc.cxx.

{
  void* p = malloc (size);
  if (!p) throw std::bad_alloc();
  return p;
}

Variable Documentation

defaultCRCTable

const CRCTable CxxUtils::defaultCRCTable(0xad93d23594c935a9)

(

0xad93d23594c935a9

)

dynamic_extent

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.

valid_span_type_v

template<class T, class U>

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.