Detailed Description

Additional classes, macros, and functions that help to work more easily with the main vector types.

Classes
class	CpuId
	This class is available for x86 / AMD64 systems to read and interpret information about the CPU's capabilities. More...

struct	ImplementationT< Features >
	This class identifies the specific implementation Vc uses in the current translation unit in terms of a type. More...

class	Allocator< T >
	An allocator that uses global new and supports over-aligned types, as per [C++11 20.6.9]. More...

struct	AlignedBase< Alignment >
	Helper class to ensure a given alignment. More...

Macros
#define	Vc_DECLARE_ALLOCATOR(Type)
	Convenience macro to set the default allocator for a given `Type` to Vc::Allocator.

Typedefs
using	CurrentImplementation
	Identifies the Vc implementation used in the current translation unit.

using	VectorAlignedBase
	Helper type to ensure suitable alignment for any Vc::Vector<T> type (using the default VectorAbi).

template<typename V >
using	VectorAlignedBaseT = AlignedBase<alignof(V)>
	Variant of the above type ensuring suitable alignment only for the specified vector type `V`.

using	MemoryAlignedBase
	Helper class to ensure suitable alignment for arrays of scalar objects for any Vc::Vector<T> type (using the default VectorAbi).

template<typename V >
using	MemoryAlignedBaseT = AlignedBase<V::MemoryAlignment>
	Variant of the above type ensuring suitable alignment only for the specified vector type `V`.

using	llong = long long
	long long shorthand

using	ullong = unsigned long long
	unsigned long long shorthand

using	ulong = unsigned long
	unsigned long shorthand

using	uint = unsigned int
	unsigned int shorthand

using	ushort = unsigned short
	unsigned short shorthand

using	uchar = unsigned char
	unsigned char shorthand

using	schar = signed char
	signed char shorthand

Enumerations
enum	MallocAlignment { AlignOnVector , AlignOnCacheline , AlignOnPage }
	Enum that specifies the alignment and padding restrictions to use for memory allocation with Vc::malloc. More...

enum	Implementation : std::uint_least32_t { ScalarImpl , SSE2Impl , SSE3Impl , SSSE3Impl , SSE41Impl , SSE42Impl , AVXImpl , AVX2Impl , MICImpl , ImplementationMask = 0xfff }
	Enum to identify a certain SIMD instruction set. More...

enum	ExtraInstructions : std::uint_least32_t { Float16cInstructions = 0x01000 , Fma4Instructions = 0x02000 , XopInstructions = 0x04000 , PopcntInstructions = 0x08000 , Sse4aInstructions = 0x10000 , FmaInstructions = 0x20000 , VexInstructions = 0x40000 , Bmi2Instructions = 0x80000 , ExtraInstructionsMask = 0xfffff000u }
	The list of available instructions is not easily described by a linear list of instruction sets. More...

Functions
const char *	versionString ()

constexpr unsigned int	versionNumber ()

template<typename V , typename Parent , typename Dimension , typename RM >
std::ostream &	operator<< (std::ostream &s, const Vc::MemoryBase< V, Parent, Dimension, RM > &m)
	Prints the contents of a Memory object into a stream object.

template<class InputIt , class UnaryFunction >
UnaryFunction	simd_for_each (InputIt first, InputIt last, UnaryFunction f)
	Vc variant of the `std::for_each` algorithm.

template<typename Mask , typename T >
enable_if< is_simd_mask< Mask >::value &&is_simd_vector< T >::value, T >	iif (const Mask &condition, const T &trueValue, const T &falseValue)
	Function to mimic the ternary operator '?:' (inline-if).

template<typename T >
constexpr T	iif (bool condition, const T &trueValue, const T &falseValue)
	Overload of the above for boolean conditions.

template<typename V , typename = enable_if<Traits::is_simd_vector<V>::value>>
std::pair< V, V >	interleave (const V &a, const V &b)
	Interleaves the entries from `a` and `b` into two vectors of the same type.

template<typename T , Vc::MallocAlignment A>
T *	malloc (size_t n)
	Allocates memory on the Heap with alignment and padding suitable for vectorized access.

template<typename T >
void	free (T *p)
	Frees memory that was allocated with Vc::malloc.

void	prefetchForOneRead (const void *addr)
	Prefetch the cacheline containing `addr` for a single read access.

void	prefetchForModify (const void *addr)
	Prefetch the cacheline containing `addr` for modification.

void	prefetchClose (const void *addr)
	Prefetch the cacheline containing `addr` to L1 cache.

void	prefetchMid (const void *addr)
	Prefetch the cacheline containing `addr` to L2 cache.

void	prefetchFar (const void *addr)
	Prefetch the cacheline containing `addr` to L3 cache.

template<typename V , typename T , typename Abi >
enable_if<(V::size()==Vector< T, Abi >::size() &&sizeof(typename V::VectorEntryType)==sizeof(typename Vector< T, Abi >::VectorEntryType) &&sizeof(V)==sizeof(Vector< T, Abi >) &&alignof(V)<=alignof(Vector< T, Abi >)), V >	reinterpret_components_cast (const Vector< T, Abi > &x)
	Constructs a new Vector object of type `V` from the Vector `x`, reinterpreting the bits of `x` for the new type `V`.

template<typename M >
constexpr WhereImpl::WhereMask< M >	where (const M &mask)
	Conditional assignment.

Variables
constexpr AlignedTag	Aligned
	Use this object for a `flags` parameter to request aligned loads and stores.

constexpr UnalignedTag	Unaligned
	Use this object for a `flags` parameter to request unaligned loads and stores.

constexpr StreamingTag	Streaming
	Use this object for a `flags` parameter to request streaming loads and stores.

constexpr LoadStoreFlags::LoadStoreFlags< PrefetchFlag<> >	PrefetchDefault
	Use this object for a `flags` parameter to request default software prefetches to be emitted.

constexpr VectorSpecialInitializerZero	Zero = {}
	The special object `Vc::Zero` can be used to construct Vector and Mask objects initialized to zero/`false`.

constexpr VectorSpecialInitializerOne	One = {}
	The special object `Vc::One` can be used to construct Vector and Mask objects initialized to one/`true`.

constexpr VectorSpecialInitializerIndexesFromZero	IndexesFromZero = {}
	The special object `Vc::IndexesFromZero` can be used to construct Vector objects initialized to values 0, 1, 2, 3, 4, ...

Micro-Architecture Feature Tests
unsigned int	extraInstructionsSupported ()
	Determines the extra instructions supported by the current CPU.

bool	isImplementationSupported (Vc::Implementation impl)
	Tests whether the given implementation is supported by the system the code is executing on.

Vc::Implementation	bestImplementationSupported ()
	Determines the best supported implementation for the current system.

bool	currentImplementationSupported ()
	Tests that the CPU and Operating System support the vector unit which was compiled for.

Boolean Reductions
template<typename Mask >
constexpr bool	all_of (const Mask &m)
	Returns whether all entries in the mask `m` are `true`.

constexpr bool	all_of (bool b)
	Returns `b`.

template<typename Mask >
constexpr bool	any_of (const Mask &m)
	Returns whether at least one entry in the mask `m` is `true`.

constexpr bool	any_of (bool b)
	Returns `b`.

template<typename Mask >
constexpr bool	none_of (const Mask &m)
	Returns whether all entries in the mask `m` are `false`.

constexpr bool	none_of (bool b)
	Returns `!b`.

template<typename Mask >
constexpr bool	some_of (const Mask &m)
	Returns whether at least one entry in `m` is `true` and at least one entry in `m` is `false`.

constexpr bool	some_of (bool)
	Returns `false`.

SIMD Vector Size Macros
#define	Vc_DOUBLE_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a double_v.

#define	Vc_FLOAT_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a float_v.

#define	Vc_INT_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a int_v.

#define	Vc_UINT_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a uint_v.

#define	Vc_SHORT_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a short_v.

#define	Vc_USHORT_V_SIZE
	An integer (for use with the preprocessor) that gives the number of entries in a ushort_v.

Compiler Identification Macros
#define	Vc_ICC __INTEL_COMPILER_BUILD_DATE
	This macro is defined to a number identifying the ICC version if the current translation unit is compiled with the Intel compiler.

#define	Vc_CLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
	This macro is defined to a number identifying the Clang version if the current translation unit is compiled with the Clang compiler.

#define	Vc_APPLECLANG (__clang_major__ * 0x10000 + __clang_minor__ * 0x100 + __clang_patchlevel__)
	This macro is defined to a number identifying the Apple Clang version if the current translation unit is compiled with the Apple Clang compiler.

#define	Vc_GCC (__GNUC__ * 0x10000 + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
	This macro is defined to a number identifying the GCC version if the current translation unit is compiled with the GCC compiler.

#define	Vc_MSVC _MSC_FULL_VER
	This macro is defined to a number identifying the Microsoft Visual C++ version if the current translation unit is compiled with the Visual C++ (MSVC) compiler.

Version Macros
#define	Vc_VERSION_STRING "1.4.5"
	Contains the version string of the Vc headers.

#define	Vc_VERSION_NUMBER 0x01040a
	Contains the encoded version number of the Vc headers.

#define	Vc_VERSION_CHECK(major, minor, patch) ((major << 16) \| (minor << 8) \| (patch << 1))
	Helper macro to compare against an encoded version number.

Macro Definition Documentation

◆ Vc_ICC

#define Vc_ICC __INTEL_COMPILER_BUILD_DATE

This macro is defined to a number identifying the ICC version if the current translation unit is compiled with the Intel compiler.