Overview

AIE provides hardware support to accelerate special multiplications that can be used to accelerate specific application use cases like (but not limited to) signal processing.

Classes
struct	aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

struct	aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >
	This type provides a parametrized multiplication that implements the following compute pattern: More...

struct	aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

struct	aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >

Typedefs
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_ch_x_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_ch_xy_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStep, DataStep, CoeffType, DataType, AccumTag >

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_ch_y_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_sym_x_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_sym_xy_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_sym_y_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_x_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepY is always 1.

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_xy_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepX is equal to DataStepY.

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	aie::sliding_mul_y_ops = sliding_mul_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepX is always 1.

Functions
template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, size_t N> requires ((N >= 1) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	aie::accumulate (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const std::array< VecData, N > &data) -> operand_base_type_t< Acc >
	Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.

template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, Vector... NextVecData> requires ((is_same_vector_v<VecData, NextVecData> && ...) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	aie::accumulate (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) -> operand_base_type_t< Acc >
	Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.

template<unsigned Lanes, unsigned CoeffStart = 0, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData>
auto	aie::accumulate (const VecCoeff &coeff, const VecData &data, const NextVecData &...next_data)

template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, size_t N> requires (N >= 1)
auto	aie::accumulate (const VecCoeff &coeff, unsigned coeff_start, const std::array< VecData, N > &data) -> accum< detail::accum_tag_or_default_t< AccumTag, typename VecCoeff::value_type, typename VecData::value_type >, Lanes >
	Performs a weighted addition over multiple vectors.

template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData> requires ((is_same_vector_v<VecData, NextVecData> && ...))
auto	aie::accumulate (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) -> accum< detail::accum_tag_or_default_t< AccumTag, typename VecCoeff::value_type, typename VecData::value_type >, Lanes >
	Performs a weighted addition over multiple vectors.

Class Documentation

◆ aie::sliding_mul_ch_ops

struct aie::sliding_mul_ch_ops

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::AIE_ML))
struct aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

Note: Only supported from AIE-ML.

This type provides a parametrized multiplication that implements the following compute pattern:

DSX = DataStepX
DSY = DataStepY
CS  = CoeffStep
P   = Points
C   = Channels
L   = Lanes
c_s = coeff_start
d_s = data_start
 
for l in 0:L
  for p in 0:P
    out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DSX)) * C + (l % C) * DSY]
 
More explicitly:
 
out[0]   = coeff[c_s * C        ] * data[ d_s                  * C              ] + coeff[(c_s + CS) * C        ] * data[(d_s +                 DSX) * C              ] + ... + coeff[(c_s + (P-1) * CS) * C        ] * data[(d_s +            (P-1)  * DSX) * C              ]
out[1]   = coeff[c_s * C +   1  ] * data[ d_s                  * C +         DSY] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +                 DSX) * C +         DSY] + ... + coeff[(c_s + (P-1) * CS) * C +   1  ] * data[(d_s +            (P-1)  * DSX) * C +         DSY]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s                  * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s +                 DSX) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s +            (P-1)  * DSX) * C + (C-1) * DSY]
out[C]   = coeff[c_s * C +      ] * data[(d_s +           DSX) * C              ] + coeff[(c_s + CS) * C        ] * data[(d_s +       (1 + 1) * DSX) * C              ] + ... + coeff[(c_s + (P-1) * CS) + C        ] * data[(d_s +      (1  + (P-1)) * DSX) * C              ]
out[C+1] = coeff[c_s * C +   1  ] * data[(d_s +           DSX) * C +         DSY] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +       (1 + 1) * DSX) * C +         DSY] + ... + coeff[(c_s + (P-1) * CS) + C +   1  ] * data[(d_s +      (1  + (P-1)) * DSX) * C +         DSY]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DSX) * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DSX) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DSX) * C + (C-1) * DSY]

Supported parameters for sliding_mul_ch with 32b accumulation
Types (coeff x data)	Native lanes	Native points	Channels	CoeffStep	DataStep	coeff_start	data_start
8b x 8b	4	4	8	1	1	Unsigned	Signed
8b x 8b	8	8	4	1	1	Unsigned	Signed

Note: Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted .; Native points denotes the number of multiplications and additions handled by a single intrinsic call. Other values are emulated internally by zeroing certain coeff lanes and/or unrolling multiple intrinsic calls.; coeff_start and data_start wrap around if greater than the number of values.

Template Parameters

Outputs	Number of output samples per channel.
Channels	Number of channels.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_ch_x_ops, sliding_mul_ch_y_ops, sliding_mul_ch_xy_ops

Public Types
using	accum_type = accum< detail::accum_tag_or_default_t< AccumTag, CoeffType, DataType >, Lanes >

using	coeff_type = typename impl_type::coeff_type

using	data_type = typename impl_type::data_type

using	impl_type = detail::sliding_mul_ch< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType >

enum class	MulType { Mul , Acc_Mul , NegMul }

Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	negmul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Static Public Attributes
static constexpr unsigned	columns_per_mul = impl_type::columns_per_mul

static constexpr unsigned	Lanes = Outputs * Channels

static constexpr unsigned	lanes = impl_type::lanes

static constexpr unsigned	lanes_per_mul = impl_type::lanes_per_mul

static constexpr unsigned	num_mul = impl_type::num_mul

static constexpr unsigned	points = impl_type::points

Member Typedef Documentation

◆ accum_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

◆ coeff_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

◆ data_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

◆ impl_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_ch<Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

Member Enumeration Documentation

◆ MulType

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_ch_ops::MulType

strong

Enumerator
Mul
Acc_Mul
NegMul

Member Function Documentation

◆ mac()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

acc	Accumulator that is added to the result of the multiplication.
coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul_common()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

static constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ negmul()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::negmul	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

Member Data Documentation

◆ columns_per_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul

staticconstexpr

◆ Lanes

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::Lanes = Outputs * Channels

staticconstexpr

◆ lanes

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes

staticconstexpr

◆ lanes_per_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul

staticconstexpr

◆ num_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul

staticconstexpr

◆ points

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points

staticconstexpr

◆ aie::sliding_mul_ops

struct aie::sliding_mul_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
struct aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

This type provides a parametrized multiplication that implements the following compute pattern:

DSX = DataStepX
DSY = DataStepY
CS  = CoeffStep
P   = Points
L   = Lanes
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * data[d_s +            ] + coeff[c_s + CS] * data[d_s +               DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s +               (P-1) * DSX]
out[1]   = coeff[c_s] * data[d_s +         DSY] + coeff[c_s + CS] * data[d_s +         DSY + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s +         DSY + (P-1) * DSX]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DSY] + coeff[c_s + CS] * data[d_s + (L-1) * DSY + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) * DSY + (P-1) * DSX]

Supported AIE parameters for sliding_mul
Types (coeff x data)	Native accum.		Native lanes	Native points	CoeffStep	DataStepX	DataStepY	coeff_start	data_start
8b x 8b	AIE-ML	acc32	32	8	1,2	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
16b x 16b	AIE	acc48	8 16	32/Lanes	1,2,3,4	1	1	Unsigned smaller than 16	Signed
	AIE-ML	acc32	16	4	1,2	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
	AIE-ML	acc64	16	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
16b x 32b	AIE	acc48	8 16	16/Lanes	1,2,3,4	1,2,3,4	1,2 1	Unsigned smaller than 16	Signed
	AIE	acc80	8	16/Lanes	1,2,3,4	1,2,3,4	1,2	Unsigned smaller than 16	Signed
	AIE-ML	acc64	16	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
32b x 16b	AIE	acc48	8 16	16/Lanes	1,2,3,4	1,2,3,4	1,2 1	Unsigned smaller than 16	Signed
	AIE	acc80	8	16/Lanes	1,2,3,4	1,2,3,4	1,2	Unsigned smaller than 16	Signed
	AIE-ML	acc64	16	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
32b x 32b	AIE	acc80	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
32b x 32b	AIE-ML	acc64	16	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
16b x c16b	AIE	cacc48	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
16b x c16b	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
16b x c32b	AIE	cacc48	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
	AIE	cacc80	4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
32b x c16b	AIE	cacc48	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
	AIE	cacc80	4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
32b x c32b	AIE	cacc80	2 4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
32b x c32b	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c16b x 16b	AIE	cacc48	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c16b x 16b	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c16b x 32b	AIE	cacc48	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
	AIE	cacc80	4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c16b x c16b	AIE	cacc48	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c16b x c16b	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c16b x c32b	AIE	cacc48	4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE	cacc80	4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	8¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c32b x 16b	AIE	cacc48	4 8	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
	AIE	cacc80	4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c32b x 32b	AIE	cacc80	2 4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x 32b	AIE-ML	cacc64	16¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c32b x c16b	AIE	cacc48	4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE	cacc80	4	4/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
	AIE-ML	cacc64	8¹	4	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
c32b x c32b	AIE	cacc80	2	2/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x c32b	AIE-ML	cacc64	8	1	1	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed

Supported AIE parameters for sliding_mul with floating point accumulation
Types (coeff x data)	Native accum.		Native lanes	Native points	CoeffStep	DataStepX	DataStepY	coeff_start	data_start
bfloat16 x bfloat16	AIE-ML	accfloat	16	1	1,2	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
float x float	AIE	accfloat	8	1	1,2,3,4	1,2,3,4	1,2	Unsigned smaller than 16	Signed
float x float	AIE-ML	accfloat	16	1	1,2	1,2	1,2 (needs to match DataStepX)	Unsigned	Signed
float x cfloat	AIE	caccfloat	4	1	1,2,3	1,2,3,4	1,2,3	Unsigned smaller than 16	Signed
cfloat x float	AIE	caccfloat	4	1	1,2,3,4	1,2,3,4	1,2,3	Unsigned smaller than 16	Signed
cfloat x cfloat	AIE	caccfloat	4	1	1,2,3	1,2,3,4	1,2,3	Unsigned smaller than 16	Signed

Note: Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.; Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.; coeff_start and data_start wrap around if greater than the number of values.

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection accross lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

Public Types
using	accum_type = accum< detail::accum_tag_or_default_t< AccumTag, CoeffType, DataType >, Lanes >

using	coeff_type = typename impl_type::coeff_type

using	data_type = typename impl_type::data_type

using	impl_type = detail::sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType >

enum class	MulType { Mul , Acc_Mul , NegMul }

Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))
static constexpr accum_type	negmul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Static Public Attributes
static constexpr unsigned	columns_per_mul = impl_type::columns_per_mul

static constexpr unsigned	lanes = impl_type::lanes

static constexpr unsigned	lanes_per_mul = impl_type::lanes_per_mul

static constexpr unsigned	num_mul = impl_type::num_mul

static constexpr unsigned	points = impl_type::points

Member Typedef Documentation

◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

Member Enumeration Documentation

◆ MulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_ops::MulType

strong

Enumerator
Mul
Acc_Mul
NegMul

Member Function Documentation

◆ mac()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

acc	Accumulator that is added to the result of the multiplication.
coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul_common()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

static constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ negmul()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits))

static constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::negmul	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

Member Data Documentation

◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul

staticconstexpr

◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes

staticconstexpr

◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul

staticconstexpr

◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul

staticconstexpr

◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points

staticconstexpr

◆ aie::sliding_mul_sym_ops

struct aie::sliding_mul_sym_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::AIE))
struct aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

Note: Only supported in AIE.

This type provides a parametrized multiplication that implements the following compute pattern:

L   = Lanes
P   = Points
CS  = CoeffStep
DSX = DataStepX
DSY = DataStepY
c_s = coeff_start
d_s = data_start
OP  = Operation type: '+' for symmetric, '-' for anisymmetric
 
out[0]   = coeff[c_s] * (data[d_s +            ] OP data[d_s +               (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s +                         DSX] OP data[d_s +               (P-2) * DSX]) + ...
                                                                                           + coeff[c_s + (P/2-1 * CS)] * (data[d_s +               (P/2-1) * DSX] OP data[d_s +                 P/2 * DSX]);
out[1]   = coeff[c_s] * (data[d_s +         DSY] OP data[d_s +         DSY + (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s +         DSY +           DSX] OP data[d_s +         DSY + (P-2) * DSX]) + ...
                                                                                           + coeff[c_s + (P/2-1 * CS)] * (data[d_s +         DSY + (P/2-1) * DSX] OP data[d_s +         DSY +   P/2 * DSX]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DSY] OP data[d_s + (L-1) * DSY + (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s + (L-1) * DSY +           DSX] OP data[d_s + (L-1) * DSY + (P-2) * DSX]) + ...
                                                                                           + coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) * DSY + (P/2-1) * DSX] OP data[d_s + (L-1) * DSY +   P/2 * DSX]);

Supported parameters for sliding_mul_sym with 48b accumulation
Types (coeff x data)	Native lanes	Native points	CoeffStep	DataStepX	DataStepY	coeff_start	data_start
16b x 16b	8 16	64/Lanes	1,2,3,4	1	1	Unsigned smaller than 16	Signed
16b x 32b	8 16	32/Lanes	1,2,3,4	1,2,3,4	1,2 1	Unsigned smaller than 16	Signed
32b x 16b	8 16	32/Lanes	1,2,3,4	1,2,3,4	1,2 1	Unsigned smaller than 16	Signed
16b x c16b	4 8	32/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c16b x 16b	4 8	32/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c16b x c16b	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c16b x 32b	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
32b x c16b	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c32b x 16b	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
16b x c32b	4 8	16/Lanes	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
c32b x c16b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c16b x c32b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed

Supported parameters for sliding_mul_sym with 80b accumulation
Types (coeff x data)	Native lanes	Native points	CoeffStep	DataStepX	DataStepY	coeff_start	data_start
32b x 16b	8	4	1,2,3,4	1,2,3,4	1,2	Unsigned smaller than 16	Signed
16b x 32b	8	4	1,2,3,4	1,2,3,4	1,2	Unsigned smaller than 16	Signed
32b x 32b	4	4	1,2,3,4	1,2,3,4	1,2,3,4 1,2	Unsigned smaller than 16	Signed
32b x c16b	4	4	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c16b x 32b	4	4	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x 16b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
16b x c32b	4	4	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x c16b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c16b x c32b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x 32b	2 4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
32b x c32b	2 4	8/Lanes	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x c32b	2	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed

Note: Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.; Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection across lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

Public Types
using	accum_type = accum< detail::accum_tag_or_default_t< AccumTag, CoeffType, DataType >, Lanes >

using	coeff_type = typename impl_type::coeff_type

using	data_type = typename impl_type::data_type

using	impl_type = detail::sliding_mul_sym< Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType >

enum class	SymMulType { Sym , Antisym , Acc_Sym , Acc_Antisym }

Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
	Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
	Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
	Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
	Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
	Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
	Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start, const Acc &...acc)

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, const Acc &...acc)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
	Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
	Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
	Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Static Public Attributes
static constexpr unsigned	columns_per_mul = impl_type::columns_per_mul

static constexpr unsigned	lanes = impl_type::lanes

static constexpr unsigned	lanes_per_mul = impl_type::lanes_per_mul

static constexpr unsigned	num_mul = impl_type::num_mul

static constexpr unsigned	points = impl_type::points

Member Typedef Documentation

◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_sym<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

Member Enumeration Documentation

◆ SymMulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_sym_ops::SymMulType

strong

Enumerator
Sym
Antisym
Acc_Sym
Acc_Antisym

Member Function Documentation

◆ mac_antisym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mac_antisym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mac_antisym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
ldata	Vector of left data samples. The size is limitted to vectors of up to 512 bits.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata	Vector of right data samples. The size is limitted to vectors of up to 512 bits.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mac_sym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mac_sym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mac_sym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

acc	Accumulator to be added to the result of the multiplication.
coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
ldata	Vector of left data samples. The size is limitted to vectors of up to 512 bits.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata	Vector of right data samples. The size is limitted to vectors of up to 512 bits.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mul_antisym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul_antisym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mul_antisym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
ldata	Vector of left data samples. The size is limitted to vectors of up to 512 bits.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata	Vector of right data samples. The size is limitted to vectors of up to 512 bits.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mul_common() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ mul_common() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ mul_common() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ mul_sym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

inlinestaticconstexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
data_start	Index of the first data element to be used in the multiplication.

◆ mul_sym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
data	Vector of data samples.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata_start	Index of the first right data element to be used in the multiplication.

◆ mul_sym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

inlinestaticconstexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

coeff	Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
coeff_start	Index of the first coefficient element to be used in the multiplication.
ldata	Vector of left data samples. The size is limitted to vectors of up to 512 bits.
ldata_start	Index of the first left data element to be used in the multiplication.
rdata	Vector of right data samples. The size is limitted to vectors of up to 512 bits.
rdata_start	Index of the first right data element to be used in the multiplication.

Member Data Documentation

◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul

staticconstexpr

◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes

staticconstexpr

◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul

staticconstexpr

◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul

staticconstexpr

◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points

staticconstexpr

◆ aie::sliding_mul_sym_uct_ops

struct aie::sliding_mul_sym_uct_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::AIE))
struct aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >

Note: Only supported in AIE.

This type provides a parametrized multiplication across the lower half of its lanes (equivalent to sliding_mul_sym_ops), and upshifts one selected set of data in the upper half of the lanes.

It implements the following compute pattern:

L   = Lanes
P   = Points
CS  = CoeffStep
DS  = DataStep
c_s = coeff_start
d_s = data_start
ups = uct_shift
 
out[0]     = coeff[c_s] * (data[d_s +             ] + data[d_s +     (P-1) * DS]) + coeff[c_s +           CS] * (data[d_s +               DS] + data[d_s +       (P-2) * DS]) + ...
                                                                                  + coeff[c_s + (P/2-1 * CS)] * (data[d_s +     (P/2-1) * DS] + data[d_s +         P/2 * DS]);
out[1]     = coeff[c_s] * (data[d_s +           DS] + data[d_s +         P * DS]) + coeff[c_s +           CS] * (data[d_s +           2 * DS] + data[d_s +       (P-1) * DS]) + ...
                                                                                  + coeff[c_s + (P/2-1 * CS)] * (data[d_s +         P/2 * DS] + data[d_s +     (P/2+1) * DS]);
...
out[L/2-1] = coeff[c_s] * (data[d_s + (L/2-1) * DS] + data[d_s + (P+L/2-2) * DS]) + coeff[c_s +           CS] * (data[d_s +         L/2 * DS] + data[d_s +   (P+L/2-3) * DS]) + ...
                                                                                  + coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2+L/2-2) * DS] + data[d_s + (P/2+L/2-1) * DS]);
out[L/2]   = data[d_s +               P/2 * DS] << ups
out[L/2+1] = data[d_s +           (P/2+1) * DS] << ups
...
out[L-1]   = data[d_s +       (P/2+L/2-1) * DS] << ups

Supported parameters for sliding_mul_sym_uct with 48b accumulation
Types (coeff x data)	Native lanes	Native points	CoeffStep	DataStepX	DataStepY	coeff_start	data_start
c16b x c16b	4	4	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
32b x c16b	4	4	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed
c32b x c16b	4	2	1,2,3,4	1,2,3,4	1,2,3,4	Unsigned smaller than 16	Signed

Note: Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.; Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane in the first half of the output Lanes.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStep	Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_sym_ops

Public Types
using	accum_type = accum< detail::accum_tag_or_default_t< AccumTag, CoeffType, DataType >, Lanes >

using	coeff_type = typename impl_type::coeff_type

using	data_type = typename impl_type::data_type

using	impl_type = detail::sliding_mul_sym_uct< Lanes, Points, CoeffStep, DataStep, accum_bits, CoeffType, DataType >

enum class	SymMulType { Sym , Antisym , Acc_Sym , Acc_Antisym }

Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift, const Acc &...acc)

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift, const Acc &...acc)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)

template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type	mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)

Static Public Attributes
static constexpr unsigned	columns_per_mul = impl_type::columns_per_mul

static constexpr unsigned	lanes = impl_type::lanes

static constexpr unsigned	lanes_per_mul = impl_type::lanes_per_mul

static constexpr unsigned	num_mul = impl_type::num_mul

static constexpr unsigned	points = impl_type::points

Member Typedef Documentation

◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_sym_uct<Lanes, Points, CoeffStep, DataStep, accum_bits, CoeffType, DataType>

Member Enumeration Documentation

◆ SymMulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_sym_uct_ops::SymMulType

strong

Enumerator
Sym
Antisym
Acc_Sym
Acc_Antisym

Member Function Documentation

◆ mac_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_antisym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mac_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_antisym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mac_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_sym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mac_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_sym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mul_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_antisym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mul_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_antisym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mul_common() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ mul_common() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_common	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift,
		const Acc &...	acc
	)

inlinestaticconstexpr

◆ mul_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_sym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

◆ mul_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

static constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_sym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

inlinestaticconstexpr

Member Data Documentation

◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul

staticconstexpr

◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes

staticconstexpr

◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul

staticconstexpr

◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul

staticconstexpr

◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

constexpr unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::points = impl_type::points

staticconstexpr

Typedef Documentation

◆ sliding_mul_ch_x_ops

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_x_ops = typedef sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>

Note: Only supported from AIE-ML.

Similar to sliding_mul_ch_ops, but DataStepY is always 1.

DSX = DataStepX
CS  = CoeffStep
P   = Points
C   = Channels
L   = Lanes
c_s = coeff_start
d_s = data_start
 
for l in 0:L
  for p in 0:P
    out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DSX)) * C + (l % C)]
 
More explicitly:
 
out[0]   = coeff[c_s * C        ] * data[ d_s                  * C              ] + coeff[(c_s + CS) * C        ] * data[(d_s +                 DSX) * C              ] + ... + coeff[(c_s + (P-1) * CS) * C        ] * data[(d_s +            (P-1)  * DSX) * C              ]
out[1]   = coeff[c_s * C +   1  ] * data[ d_s                  * C +           1] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +                 DSX) * C +           1] + ... + coeff[(c_s + (P-1) * CS) * C +   1  ] * data[(d_s +            (P-1)  * DSX) * C +           1]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s                  * C +       (C-1)] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s +                 DSX) * C +       (C-1)] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s +            (P-1)  * DSX) * C +       (C-1)]
out[C]   = coeff[c_s * C +      ] * data[(d_s +           DSX) * C              ] + coeff[(c_s + CS) * C +      ] * data[(d_s +       (1 + 1) * DSX) * C              ] + ... + coeff[(c_s + (P-1) * CS) + C        ] * data[(d_s +      (1  + (P-1)) * DSX) * C              ]
out[C+1] = coeff[c_s * C +   1  ] * data[(d_s +           DSX) * C +           1] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +       (1 + 1) * DSX) * C +           1] + ... + coeff[(c_s + (P-1) * CS) + C +   1  ] * data[(d_s +      (1  + (P-1)) * DSX) * C +           1]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DSX) * C +       (C-1)] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DSX) * C +       (C-1)] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DSX) * C +       (C-1)]

Template Parameters

Outputs	Number of output samples.
Channels	Number of channels.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_ch_ops, sliding_mul_ch_y_ops, sliding_mul_ch_xy_ops

◆ sliding_mul_ch_xy_ops

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_xy_ops = typedef sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, DataStep, DataStep, CoeffType, DataType, AccumTag>

Note: Only supported from AIE-ML.

Similar to sliding_mul_ch_ops, but DataStepX is equal to DataStepY.

DS  = DataStep
CS  = CoeffStep
P   = Points
C   = Channels
L   = Lanes
c_s = coeff_start
d_s = data_start
 
for l in 0:L
  for p in 0:P
    out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DS)) * C + (l % C) * DS]
 
More explicitly:
 
out[0]   = coeff[c_s * C        ] * data[ d_s                 * C             ] + coeff[(c_s + CS) * C        ] * data[(d_s +                 DS) * C             ] + ... + coeff[(c_s + (P-1) * CS) * C        ] * data[(d_s +            (P-1)  * DS) * C             ]
out[1]   = coeff[c_s * C +   1  ] * data[ d_s                 * C +         DS] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +                 DS) * C +         DS] + ... + coeff[(c_s + (P-1) * CS) * C +   1  ] * data[(d_s +            (P-1)  * DS) * C +         DS]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s                 * C + (C-1) * DS] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s +                 DS) * C + (C-1) * DS] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s +            (P-1)  * DS) * C + (C-1) * DS]
out[C]   = coeff[c_s * C +      ] * data[(d_s +           DS) * C             ] + coeff[(c_s + CS) * C        ] * data[(d_s +       (1 + 1) * DS) * C             ] + ... + coeff[(c_s + (P-1) * CS) + C        ] * data[(d_s +      (1  + (P-1)) * DS) * C             ]
out[C+1] = coeff[c_s * C +   1  ] * data[(d_s +           DS) * C +         DS] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +       (1 + 1) * DS) * C +         DS] + ... + coeff[(c_s + (P-1) * CS) + C +   1  ] * data[(d_s +      (1  + (P-1)) * DS) * C +         DS]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DS) * C + (C-1) * DS] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DS) * C + (C-1) * DS] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DS) * C + (C-1) * DS]

Template Parameters

Outputs	Number of output samples.
Channels	Number of channels.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStep	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_ch_ops, sliding_mul_ch_x_ops, sliding_mul_ch_y_ops

◆ sliding_mul_ch_y_ops

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_y_ops = typedef sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>

Note: Only supported from AIE-ML.

Similar to sliding_mul_ch_ops, but DataStepX is always 1.

DSY = DataStepY
CS  = CoeffStep
P   = Points
C   = Channels
L   = Lanes
c_s = coeff_start
d_s = data_start
 
for l in 0:L
  for p in 0:P
    out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p))) * C + (l % C) * DSY]
 
More explicitly:
 
out[0]   = coeff[c_s * C        ] * data[ d_s            * C              ] + coeff[(c_s + CS) * C        ] * data[(d_s +             1) * C              ] + ... + coeff[(c_s + (P-1) * CS) * C        ] * data[(d_s +             (P-1)) * C              ]
out[1]   = coeff[c_s * C +   1  ] * data[ d_s            * C +         DSY] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +             1) * C +         DSY] + ... + coeff[(c_s + (P-1) * CS) * C +   1  ] * data[(d_s +             (P-1)) * C +         DSY]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s            * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s +             1) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s +            (P-1) ) * C + (C-1) * DSY]
out[C]   = coeff[c_s * C +      ] * data[(d_s +       1) * C              ] + coeff[(c_s + CS) * C        ] * data[(d_s +       (1 + 1)) * C              ] + ... + coeff[(c_s + (P-1) * CS) + C        ] * data[(d_s +      (1  + (P-1))) * C              ]
out[C+1] = coeff[c_s * C +   1  ] * data[(d_s +       1) * C +         DSY] + coeff[(c_s + CS) * C +   1  ] * data[(d_s +       (1 + 1)) * C +         DSY] + ... + coeff[(c_s + (P-1) * CS) + C +   1  ] * data[(d_s +      (1  + (P-1))) * C +         DSY]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C) * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1)) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1))) * C + (C-1) * DSY]

Template Parameters

Outputs	Number of output samples.
Channels	Number of channels.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_ch_ops, sliding_mul_ch_x_ops, sliding_mul_ch_xy_ops

◆ sliding_mul_sym_x_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_x_ops = typedef sliding_mul_sym_ops<Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>

Note: Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepY is always 1.

L   = Lanes
P   = Points
CS  = CoeffStep
DSX = DataStepX
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * (data[d_s +      ] + data[d_s +         (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s +                   DSX] + data[d_s +         (P-2) * DSX]) + ...
                                                                              + coeff[c_s + (P/2-1 * CS)] * (data[d_s +         (P/2-1) * DSX] + data[d_s +           P/2 * DSX]);
out[1]   = coeff[c_s] * (data[d_s +     1] + data[d_s +     1 + (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s +     1 +           DSX] + data[d_s +     1 + (P-2) * DSX]) + ...
                                                                              + coeff[c_s + (P/2-1 * CS)] * (data[d_s +     1 + (P/2-1) * DSX] + data[d_s +     1 +   P/2 * DSX]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1)] + data[d_s + (L-1) + (P-1) * DSX]) + coeff[c_s +           CS] * (data[d_s + (L-1) +           DSX] + data[d_s + (L-1) + (P-2) * DSX]) + ...
                                                                              + coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) + (P/2-1) * DSX] + data[d_s + (L-1) +   P/2 * DSX]);

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_sym_ops

◆ sliding_mul_sym_xy_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_xy_ops = typedef sliding_mul_sym_ops<Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag>

Note: Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepX is equal to DataStepY.

L   = Lanes
P   = Points
CS  = CoeffStep
DS  = DataStepXY
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * (data[d_s +           ] + data[d_s +   (P-1) * DS]) + coeff[c_s +           CS] * (data[d_s +             DS] + data[d_s +     (P-2) * DS]) + ...
                                                                            + coeff[c_s + (P/2-1 * CS)] * (data[d_s +   (P/2-1) * DS] + data[d_s +       P/2 * DS]);
out[1]   = coeff[c_s] * (data[d_s +         DS] + data[d_s +       P * DS]) + coeff[c_s +           CS] * (data[d_s +         2 * DS] + data[d_s +     (P-1) * DS]) + ...
                                                                            + coeff[c_s + (P/2-1 * CS)] * (data[d_s +       P/2 * DS] + data[d_s +   (P/2+1) * DS]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DS] + data[d_s + (P+L-2) * DS]) + coeff[c_s +           CS] * (data[d_s +         L * DS] + data[d_s +   (P+L-3) * DS]) + ...
                                                                            + coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2+L-2) * DS] + data[d_s + (P/2+L-1) * DS]);

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepXY	Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_sym_ops

◆ sliding_mul_sym_y_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_y_ops = typedef sliding_mul_sym_ops<Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>

Note: Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepX is always 1.

L   = Lanes
P   = Points
CS  = CoeffStep
DSY = DataStepY
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * (data[d_s +            ] + data[d_s +               (P-1)]) + coeff[c_s +           CS] * (data[d_s +                     1] + data[d_s +               (P-2)]) + ...
                                                                                    + coeff[c_s + (P/2-1 * CS)] * (data[d_s +               (P/2-1)] + data[d_s +                 P/2]);
out[1]   = coeff[c_s] * (data[d_s +         DSY] + data[d_s +         DSY + (P-1)]) + coeff[c_s +           CS] * (data[d_s +         DSY +       1] + data[d_s +         DSY + (P-2)]) + ...
                                                                                    + coeff[c_s + (P/2-1 * CS)] * (data[d_s +         DSY + (P/2-1)] + data[d_s +         DSY +   P/2]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DSY] + data[d_s + (L-1) * DSY + (P-1)]) + coeff[c_s +           CS] * (data[d_s + (L-1) * DSY +       1] + data[d_s + (L-1) * DSY + (P-2)]) + ...
                                                                                    + coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) * DSY + (P/2-1)] + data[d_s + (L-1) * DSY +   P/2]);

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection across lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also: sliding_mul_sym_ops

◆ sliding_mul_x_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_x_ops = typedef sliding_mul_ops<Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>

Similar to sliding_mul_ops, but DataStepY is always 1.

L   = Lanes
P   = Points
CS  = CoeffStep
DSX = DataStepX
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * data[d_s +     0] + coeff[c_s + CS] * data[d_s +         DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s +         (P-1) * DSX]
out[1]   = coeff[c_s] * data[d_s +     1] + coeff[c_s + CS] * data[d_s +     1 + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s +     1 + (P-1) * DSX]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1)] + coeff[c_s + CS] * data[d_s + (L-1) + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) + (P-1) * DSX]

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepX	Step used to select elements from the data buffer. This step is applied to element selection within a lane.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

◆ sliding_mul_xy_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_xy_ops = typedef sliding_mul_ops<Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag>

Similar to sliding_mul_ops, but DataStepX is equal to DataStepY.

L   = Lanes
P   = Points
CS  = CoeffStep
DS  = DataStepXY
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * data[d_s +           ] + coeff[c_s + CS] * data[d_s +     DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s +   (P-1) * DS]
out[1]   = coeff[c_s] * data[d_s +         DS] + coeff[c_s + CS] * data[d_s + 2 * DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s +       P * DS]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DS] + coeff[c_s + CS] * data[d_s + L * DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P+L-2) * DS]

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepXY	Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

◆ sliding_mul_y_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_y_ops = typedef sliding_mul_ops<Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>

Similar to sliding_mul_ops, but DataStepX is always 1.

L   = Lanes
P   = Points
CS  = CoeffStep
DSY = DataStepY
c_s = coeff_start
d_s = data_start
 
out[0]   = coeff[c_s] * data[d_s +            ] + coeff[c_s + CS] * data[d_s +               1] + ... + coeff[c_s + (P-1) * CS] * data[d_s +               (P-1)]
out[1]   = coeff[c_s] * data[d_s +         DSY] + coeff[c_s + CS] * data[d_s +         DSY + 1] + ... + coeff[c_s + (P-1) * CS] * data[d_s +         DSY + (P-1)]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DSY] + coeff[c_s + CS] * data[d_s + (L-1) * DSY + 1] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) * DSY + (P-1)]

Template Parameters

Lanes	Number of output elements.
Points	Number of data elements used to compute each lane.
CoeffStep	Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
DataStepY	Step used to select elements from the data buffer. This step is applied to element selection accross lanes.
CoeffType	Type of the coefficient elements.
DataType	Type of the data elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

Function Documentation

◆ accumulate() [1/5]

template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, size_t N>
requires ((N >= 1) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::accumulate	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const std::array< VecData, N > &	data
	)		-> operand_base_type_t<Acc>

Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \) for \( n \geq (C + start) \) and an accumulator \( acc \), the result is an accumulator of the form \( out = acc + \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

The operation consists on a parametrized multiplication that implements the following compute pattern:

L   = Lanes
C   = sizeof...(next_data) + 1
c_s = coeff_start
 
out[0]   = acc[0]   + coeff[c_s] * data[0]   + coeff[c_s + 1] * next_data_0[0]   + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1]   = acc[1]   + coeff[c_s] * data[1]   + coeff[c_s + 1] * next_data_0[1]   + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = acc[L-1] + coeff[c_s] * data[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

In the following example, accumulate multiplies data0 by 1, data1 by 2 and data2 by 3 respectively:

aie::accum<acc80, 8> acc;
aie::vector<int, 4> coeffs{1, 2, 3};
aie::vector<int, 8> data0{...}, data1{...}, data2{...};
std::array<aie::vector<int, 8>, 3> data{data0, data1, data2};
 
acc = aie::accumulate(acc, coeffs, 0, data);

Template Parameters

Lanes Number of output elements.

Parameters

acc	Accumulator to which the result of the accumulation is added (or subtracted). The type must meet aie::AccumOrOp.
coeff	Vector of coefficients. Size is limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	First element from the coeff vector to be used.
data	Array of data vectors

◆ accumulate() [2/5]

template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, Vector... NextVecData>
requires ((is_same_vector_v<VecData, NextVecData> && ...) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::accumulate	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		const NextVecData &...	next_data
	)		-> operand_base_type_t<Acc>

Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \) for \( n \geq (C + start) \) and an accumulator \( acc \), the result is an accumulator of the form \( out = acc + \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

The operation consists on a parametrized multiplication that implements the following compute pattern:

L   = Lanes
C   = sizeof...(next_data) + 1
c_s = coeff_start
 
out[0]   = acc[0]   + coeff[c_s] * data[0]   + coeff[c_s + 1] * next_data_0[0]   + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1]   = acc[1]   + coeff[c_s] * data[1]   + coeff[c_s + 1] * next_data_0[1]   + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = acc[L-1] + coeff[c_s] * data[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

In the following example, accumulate multiplies data0 by 1, data1 by 2 and data2 by 3 respectively:

aie::accum<acc80, 8> acc;
aie::vector<int, 4> coeffs{1, 2, 3};
aie::vector<int, 8> data0{...}, data1{...}, data2{...};
 
acc = aie::accumulate(acc, coeffs, 0, data0, data1, data2);

Template Parameters

Lanes Number of output elements.

Parameters

acc	Accumulator to which the result of the accumulation is added (or subtracted). The type must meet aie::AccumOrOp.
coeff	Vector of coefficients. Size is limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	First element from the coeff vector to be used.
data	First vector of data.
next_data	Remaining data vectors.

◆ accumulate() [3/5]

template<unsigned Lanes, unsigned CoeffStart = 0, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData>

auto aie::accumulate	(	const VecCoeff &	coeff,
		const VecData &	data,
		const NextVecData &...	next_data
	)

Deprecated:: This function is deprecated. Use accumulate(const VecCoeff & coeff, unsigned coeff_start, const VecData & data, const NextVecData &... next_data ) instead.

See also: accumulate(const VecCoeff & coeff, unsigned coeff_start, const VecData & data, const NextVecData &... next_data )

◆ accumulate() [4/5]

template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, size_t N>
requires (N >= 1)

auto aie::accumulate	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const std::array< VecData, N > &	data
	)		-> accum<detail::accum_tag_or_default_t<AccumTag, typename VecCoeff::value_type, typename VecData::value_type>, Lanes>

Performs a weighted addition over multiple vectors.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \), for \( n \geq (C + start) \), the result is an accumulator of the form \( out = \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

This function provides a parametrized multiplication that implements the following compute pattern:

L   = Lanes
C   = sizeof...(next_data) + 1
c_s = coeff_start
 
out[0]   = coeff[c_s] * data_0[0]   + coeff[c_s + 1] * next_data_0[0]   + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1]   = coeff[c_s] * data_0[1]   + coeff[c_s + 1] * next_data_0[1]   + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = coeff[c_s] * data_0[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

Template Parameters

Lanes	Number of output elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	First element from the coeff vector to be used.
data	Array of data vectors

◆ accumulate() [5/5]

template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData>
requires ((is_same_vector_v<VecData, NextVecData> && ...))

auto aie::accumulate	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		const NextVecData &...	next_data
	)		-> accum<detail::accum_tag_or_default_t<AccumTag, typename VecCoeff::value_type, typename VecData::value_type>, Lanes>

Performs a weighted addition over multiple vectors.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \), for \( n \geq (C + start) \), the result is an accumulator of the form \( out = \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

This function provides a parametrized multiplication that implements the following compute pattern:

L   = Lanes
C   = sizeof...(next_data) + 1
c_s = coeff_start
 
out[0]   = coeff[c_s] * data_0[0]   + coeff[c_s + 1] * next_data_0[0]   + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1]   = coeff[c_s] * data_0[1]   + coeff[c_s + 1] * next_data_0[1]   + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = coeff[c_s] * data_0[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

Template Parameters

Lanes	Number of output elements.
AccumTag	Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

Parameters

coeff	Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML respectively.
coeff_start	First element from the coeff vector to be used.
data	First vector of data.
next_data	Rest of the data vectors.

Overview

Classes

Typedefs

Functions

Class Documentation

◆ aie::sliding_mul_ch_ops

Public Types

Static Public Member Functions

Static Public Attributes

Member Typedef Documentation

◆ accum_type

◆ coeff_type

◆ data_type

◆ impl_type

Member Enumeration Documentation

◆ MulType

Member Function Documentation

◆ mac()

◆ mul()

◆ mul_common()

◆ negmul()

Member Data Documentation

◆ columns_per_mul

◆ Lanes

◆ lanes

◆ lanes_per_mul

◆ num_mul

◆ points

◆ aie::sliding_mul_ops

Public Types

Static Public Member Functions

Static Public Attributes

Member Typedef Documentation

◆ accum_type

◆ coeff_type

◆ data_type

◆ impl_type

Member Enumeration Documentation

◆ MulType

Member Function Documentation

◆ mac()

◆ mul()

◆ mul_common()

◆ negmul()

Member Data Documentation

◆ columns_per_mul

◆ lanes

◆ lanes_per_mul

◆ num_mul

◆ points

◆ aie::sliding_mul_sym_ops

Public Types

Static Public Member Functions

Static Public Attributes

Member Typedef Documentation

◆ accum_type

◆ coeff_type

◆ data_type

◆ impl_type

Member Enumeration Documentation

◆ SymMulType

Member Function Documentation

◆ mac_antisym() [1/3]

◆ mac_antisym() [2/3]

◆ mac_antisym() [3/3]

◆ mac_sym() [1/3]

◆ mac_sym() [2/3]

◆ mac_sym() [3/3]

◆ mul_antisym() [1/3]

◆ mul_antisym() [2/3]

◆ mul_antisym() [3/3]

◆ mul_common() [1/3]

◆ mul_common() [2/3]

◆ mul_common() [3/3]

◆ mul_sym() [1/3]

◆ mul_sym() [2/3]

◆ mul_sym() [3/3]

Member Data Documentation

◆ columns_per_mul

◆ lanes