Data transfer

From memory:

load()

load values from memory

load_aligned()

load values from aligned memory

load_unaligned()

load values from unaligned memory

load_as()

load values, forcing a type conversion

From a scalar:

broadcast()

broadcasting a value to all slots

broadcast_as()

broadcasting a value, forcing a type conversion

insert()

modify a single batch slot

To memory:

store()

store values to memory

store_aligned()

store values to aligned memory

store_unaligned()

store values to unaligned memory

store_as()

store values, forcing a type conversion

In place:

swizzle()

rearrange slots within the batch

slide_left()

bitwise shift the whole batch to the left

slide_right()

bitwise shift the whole batch to the right

insert()

modify a single batch slot

Between batches:

zip_lo()

interleave low halves of two batches

zip_hi()

interleave high halves of two batches


template<class T, class A = default_arch>
inline batch<T, A> broadcast(T v) noexcept

Creates a batch from the single value v.

Parameters

v – the value used to initialize the batch

Returns

a new batch instance

template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> broadcast_as(From v) noexcept

Creates a batch from the single value v and the specified batch value type To.

Parameters

v – the value used to initialize the batch

Returns

a new batch instance

template<class T, class A, size_t I>
inline batch<T, A> insert(batch<T, A> const &x, T val, index<I> pos) noexcept

Create a new batch equivalent to x but with element val set at position pos.

Parameters
  • x – batch

  • val – value to set

  • pos – index of the updated slot

Returns

copy of x with position pos set to val

template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> load_as(From const *ptr, aligned_mode) noexcept

Creates a batch from the buffer ptr and the specifed batch value type To.

The memory needs to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<class To, class A = default_arch, class From>
inline simd_return_type<From, To, A> load_as(From const *ptr, unaligned_mode) noexcept

Creates a batch from the buffer ptr and the specifed batch value type To.

The memory does not need to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<class A = default_arch, class From>
inline batch<From, A> load(From const *ptr, aligned_mode = {}) noexcept

Creates a batch from the buffer ptr.

The memory needs to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<class A = default_arch, class From>
inline batch<From, A> load(From const *ptr, unaligned_mode) noexcept

Creates a batch from the buffer ptr.

The memory does not need to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<class A = default_arch, class From>
inline batch<From, A> load_aligned(From const *ptr) noexcept

Creates a batch from the buffer ptr.

The memory needs to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<class A = default_arch, class From>
inline batch<From, A> load_unaligned(From const *ptr) noexcept

Creates a batch from the buffer ptr.

The memory does not need to be aligned.

Parameters

ptr – the memory buffer to read

Returns

a new batch instance

template<size_t N, class T, class A>
inline batch<T, A> slide_left(batch<T, A> const &x) noexcept

Slide the whole batch to the left by n bytes.

This is different from bitwise_lshift that shifts each batch element to the left.

Template Parameters

N – Amount of bytes to slide to the left.

Parameters

x – batch of integer values.

Returns

slided batch.

template<size_t N, class T, class A>
inline batch<T, A> slide_right(batch<T, A> const &x) noexcept

Slide the whole batch to the right by N bytes.

This is different from bitwise_rshift that shifts each batch element to the right.

Template Parameters

N – Amount of bytes to slide to the right.

Parameters

x – batch of integer values.

Returns

slided batch.

template<class To, class A = default_arch, class From>
inline void store_as(To *dst, batch<From, A> const &src, aligned_mode) noexcept

Copy content of batch src to the buffer dst.

The memory needs to be aligned.

Parameters
  • dst – the memory buffer to write to

  • src – the batch to copy

template<class To, class A = default_arch, class From>
inline void store_as(To *dst, batch<From, A> const &src, unaligned_mode) noexcept

Copy content of batch src to the buffer dst.

The memory does not need to be aligned.

Parameters
  • dst – the memory buffer to write to

  • src – the batch to copy

template<class A, class T>
inline void store(T *mem, batch<T, A> const &val, aligned_mode = {}) noexcept

Copy content of batch val to the buffer mem.

The memory does not need to be aligned.

Parameters
  • mem – the memory buffer to write to

  • val – the batch to copy from

template<class A, class T>
inline void store(T *mem, batch<T, A> const &val, unaligned_mode) noexcept

Copy content of batch val to the buffer mem.

The memory does not need to be aligned.

Parameters
  • mem – the memory buffer to write to

  • val – the batch to copy from

template<class A, class T>
inline void store_aligned(T *mem, batch<T, A> const &val) noexcept

Copy content of batch val to the buffer mem.

The memory needs to be aligned.

Parameters
  • mem – the memory buffer to write to

  • val – the batch to copy from

template<class A, class T>
inline void store_unaligned(T *mem, batch<T, A> const &val) noexcept

Copy content of batch val to the buffer mem.

The memory does not need to be aligned.

Parameters
  • mem – the memory buffer to write to

  • val – the batch to copy

template<class T, class A, class Vt, Vt... Values>
inline std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type swizzle(batch<T, A> const &x, batch_constant<batch<Vt, A>, Values...> mask) noexcept

Rearrange elements from x according to mask mask.

Parameters
  • x – batch

  • mask – constant batch mask of integer elements of the same size as element of x

Returns

swizzled batch

template<class T, class A>
inline batch<T, A> zip_hi(batch<T, A> const &x, batch<T, A> const &y) noexcept

Unpack and interleave data from the HIGH half of batches x and y.

Store the results in the Return value.

Parameters
  • x – a batch of integer or floating point or double precision values.

  • y – a batch of integer or floating point or double precision values.

Returns

a batch of the high part of shuffled values.

template<class T, class A>
inline batch<T, A> zip_lo(batch<T, A> const &x, batch<T, A> const &y) noexcept

Unpack and interleave data from the LOW half of batches x and y.

Store the results in the Return value.

Parameters
  • x – a batch of integer or floating point or double precision values.

  • y – a batch of integer or floating point or double precision values.

Returns

a batch of the low part of shuffled values.

The following empty types are used for tag dispatching:

struct aligned_mode

tag for load and store of aligned memory.

struct unaligned_mode

tag for load and store of unaligned memory.