FFT intrinsics

Overview

These are the intrinsics functions used for implementing FFT functionality.

For intrinsics used for addressing related to FFT please see FFT addressing.

The FFT algorithm works by executing these functions a number of times in different stages.

The number of stages is the log of the number of points in the FFT with the radix as the base of the log. For instance for a 256 point radix 2 FFT the process is split into 8 stages. The first 6 stages are the same and consist of calling the butterfly function on every input value that is supplied to it, these input values depend on the radix. In this instance (radix 2) means that every second block is processed. The input pointer is determined by by an incrementation function fft_data_incr. The twiddle values are determined by the use of two functions fft_permute_incr which determines which values within the register to use and fft_twiddle_incr which increments the pointer to the twiddle factors, thereby providing a fresh set of twiddle values.

The output of each stage becomes the input of the next stage.

The last two stages differ from the initial 6 stages in the way that the inputs are twiddles are mapped from the registers and how often the twiddles are updated from the registers.

In the case of radix 2, 256 point FFT with 32bit data, a stage will consist of 32 butterfly calls, each consuming 8 samples, 64 store operations and 64 AIE cycles total.

FFT scalar functions
unsigned	fft_zoffs (umod_t cntwrap, int step, bool wide_twiddle, bool wide_data)
	Change twiddle factor selectors.
umod_t	fft_mod_delay (umod_t cntwrap)
	Delay the count/wrap parameter.

FFT butterfly intrinsics
The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. The butterfly function performs the following pseudocode: o = a + b*func(z) p = a - b*func(z) return p::o Alternatively, the following pseudo-code can be performed. The intrinsic will be prefixed with half_ in this case: o = b*func(z) p = a + b*func(z) return p::o Where func(z) can be: func(z) = z: the normal mode func(z) = conj(z): conjugate twiddles for inverse fft applications func(z) = -j*z: multiply twiddles with minus imaginary number. Used in radix-4 kernels. func(z) = -j*conj(z): combination of the two above. See each of the following intrinsics for more specific pseudocode.
v8cacc48	butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	butterfly_dit_cj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)
v8cacc48	half_butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	half_butterfly_dit_cj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	half_butterfly_dit (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)
v8cacc48	half_butterfly_dit (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets)
v8cacc48	half_butterfly_dit_cj (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets)
v8cacc48	half_butterfly_dit (v8cacc48 acc, v8cint32 x, v8cint32 y, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj)
v8cacc48	butterfly_dit_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	butterfly_dit_cj_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, int shft)
v8cacc48	butterfly_dit_minj (v8cint32 x, v8cint32 y, unsigned int aoffsets, unsigned int boffsets, v8cint16 z, unsigned int zstart, unsigned int zoffsets, bool zconj, int shft)

Function Documentation

butterfly_dit() [1/2]

v8cacc48 butterfly_dit	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		bool	zconj,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

butterfly_dit() [2/2]

v8cacc48 butterfly_dit	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

butterfly_dit_cj()

v8cacc48 butterfly_dit_cj	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

butterfly_dit_cj_minj()

v8cacc48 butterfly_dit_cj_minj	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( (-j*conj(z)) (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( (-j*conj(z)) (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( (-j*conj(z)) (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( (-j*conj(z)) (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( (-j*conj(z)) (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( (-j*conj(z)) (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( (-j*conj(z)) (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( (-j*conj(z)) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

butterfly_dit_minj() [1/2]

v8cacc48 butterfly_dit_minj	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		bool	zconj,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

butterfly_dit_minj() [2/2]

v8cacc48 butterfly_dit_minj	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));  

o1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));  

o2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));  

o3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) -  x::y(boffsets0 )*( (-j*z) (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) -  x::y(boffsets1 )*( (-j*z) (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) -  x::y(boffsets2 )*( (-j*z) (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) -  x::y(boffsets3 )*( (-j*z) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

fft_mod_delay()

umod_t fft_mod_delay

(

umod_t

cntwrap

)

Delay the count/wrap parameter.

Parameters

cntwrap

Counts the number of FFT wraps. The MSB is the wrap bit itself.

Returns

Same value as input but delayed by some cycles.

This function is needed in the radix-4 FFT implementations where the cntwrap parameter is generated many cycles before its consumption and hence needs to be delayed.

fft_zoffs()

unsigned fft_zoffs	(	umod_t	cntwrap,
		int	step,
		bool	wide_twiddle,
		bool	wide_data
	)

Change twiddle factor selectors.

Parameters

cntwrap	Counts the number of FFT wraps. The MSB is the wrap bit itself.
step	Range {0..3}. Binary logarithm of the count wrap around (number of wraps per twiddle vector). This must be a compile time constant.
wide_twiddle	True if a wide 8 lane twiddle vector is used. This must be a compile time constant.
wide_data	True if a wide 8 lane data vector is used This must be a compile time constant.

Returns

Coefficient (twiddle) selector value for the butterfly() intrinsic.

Note

Parameters 'step', 'wide_twiddle' and 'wide_data' must be compile time constants.

The butterfly function chooses which twiddle values from the register to use with which input values, based on the returned zoffs value.

For instance if zoffs = 0x1100 then the first twiddle value is used with in[3] and in[2] and the second twiddle value is used with in[1] and in[0]. Which values in the input register correspond to in[3]-in[0] is determined by a similar mapping process in the butterfly function.

For more information on the intrinsic's behaviour you can check the following pseudocode:

unsigned fft_zoffs_test(int cntwrap, int step, bool wide_twiddle, bool wide_data) {
    int out;
    switch (step) {
    case 0:
        if (wide_data == 1)
            out = 0x76543210;
        break;
    case 1:
        cntwrap &= 1;
        if (wide_data == 0)
            out = 4*cntwrap * 0x1111     + 0x3210;
        else
            out = 4*cntwrap * 0x11111111 + 0x33221100;
        break;
    case 2:
        cntwrap &= 3;
        if (wide_data == 0)
            out = 2*cntwrap * 0x1111     + 0x1100;
        else
            out = 2*cntwrap * 0x11111111 + 0x11110000;
        break;
    case 3:
        cntwrap &= 7;
        if (wide_data == 0)
            out =   cntwrap * 0x1111;
        else
            out =   cntwrap * 0x11111111;
        break;
    }
 
    if (wide_twiddle == 0) {
        out &= 0x33333333;
    } else {
        out &= 0x77777777;
    }
    return out;
}

The following tables shows the resulting offset's the intrinsic would return when:

wide_twiddle = wide_data = 0

cntwrap	Stage=3	Stage=2	Stage=1
0	{0,0,0,0}	{0,0,1,1}	{0,1,2,3}
1	{1,1,1,1}	{2,2,3,3}	{0,1,2,3}
2	{2,2,2,2}	{0,0,1,1}	{0,1,2,3}
3	{3,3,3,3}	{2,2,3,3}	{0,1,2,3}
4	{0,0,0,0}	{0,0,1,1}	{0,1,2,3}
5	{1,1,1,1}	{2,2,3,3}	{0,1,2,3}
6	{2,2,2,2}	{0,0,1,1}	{0,1,2,3}
7	{3,3,3,3}	{2,2,3,3}	{0,1,2,3}

wide_twiddle = 1, wide_data = 0

cntwrap	Stage = 3	Stage = 2	Stage = 1
0	{0,0,0,0}	{0,0,1,1}	{0,1,2,3}
1	{1,1,1,1}	{2,2,3,3}	{4,5,6,7}
2	{2,2,2,2}	{4,4,5,5}	{0,1,2,3}
3	{3,3,3,3}	{6,6,7,7}	{4,5,6,7}
4	{4,4,4,4}	{0,0,1,1}	{0,1,2,3}
5	{5,5,5,5}	{2,2,3,3}	{4,5,6,7}
6	{6,6,6,6}	{4,4,5,5}	{0,1,2,3}
7	{7,7,7,7}	{6,6,7,7}	{4,5,6,7}

wide_twiddle = 0, wide_data = 1

cntwrap	Stage = 3	Stage = 2	Stage = 1
0	{0,0,0,0,0,0,0,0}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}
1	{1,1,1,1,1,1,1,1}	{2,2,2,2,3,3,3,3}	{0,0,1,1,2,2,2,3}
2	{2,2,2,2,1,1,1,1}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}
3	{3,3,3,3,3,3,3,3}	{2,2,2,2,3,3,3,3}	{0,0,1,1,2,2,2,3}
4	{0,0,0,0,0,0,0,0}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}
5	{1,1,1,1,1,1,1,1}	{2,2,2,2,3,3,3,3}	{0,0,1,1,2,2,2,3}
6	{2,2,2,2,1,1,1,1}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}
7	{3,3,3,3,3,3,3,3}	{2,2,2,2,3,3,3,3}	{0,0,1,1,2,2,2,3}

wide_twiddle = 1, wide_data = 1

cntwrap	Stage = 3	Stage = 2	Stage = 1	Stage = 0
0	{0,0,0,0,0,0,0,0}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}	{0,1,2,3,4,5,6,7}
1	{1,1,1,1,1,1,1,1}	{2,2,2,2,3,3,3,3}	{4,4,5,5,6,7,7,7}	{0,1,2,3,4,5,6,7}
2	{2,2,2,2,1,1,1,1}	{4,4,4,4,5,5,5,5}	{0,0,1,1,2,2,2,3}	{0,1,2,3,4,5,6,7}
3	{3,3,3,3,3,3,3,3}	{6,6,6,6,7,7,7,7}	{4,4,5,5,6,6,7,7}	{0,1,2,3,4,5,6,7}
4	{4,4,4,4,4,4,4,4}	{0,0,0,0,1,1,1,1}	{0,0,1,1,2,2,2,3}	{0,1,2,3,4,5,6,7}
5	{5,5,5,5,5,5,5,5}	{2,2,2,2,3,3,3,3}	{4,4,5,5,6,7,7,7}	{0,1,2,3,4,5,6,7}
6	{6,6,6,6,6,6,6,6}	{4,4,4,4,5,5,5,5}	{0,0,1,1,2,2,2,3}	{0,1,2,3,4,5,6,7}
7	{7,7,7,7,7,7,7,7}	{6,6,6,6,7,7,7,7}	{4,4,5,5,6,6,7,7}	{0,1,2,3,4,5,6,7}

half_butterfly_dit() [1/4]

v8cacc48 half_butterfly_dit	(	v8cacc48	acc,
		v8cint32	x,
		v8cint32	y,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  acc0  +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  acc1  +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  acc2  +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  acc3  +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	acc	Direct accumulator values for a.

half_butterfly_dit() [2/4]

v8cacc48 half_butterfly_dit	(	v8cacc48	acc,
		v8cint32	x,
		v8cint32	y,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		bool	zconj
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  acc0  +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  acc1  +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  acc2  +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  acc3  +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	acc	Direct accumulator values for a.

half_butterfly_dit() [3/4]

v8cacc48 half_butterfly_dit	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		bool	zconj,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

half_butterfly_dit() [4/4]

v8cacc48 half_butterfly_dit	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( z (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( z (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( z (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( z (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.

half_butterfly_dit_cj() [1/2]

v8cacc48 half_butterfly_dit_cj	(	v8cacc48	acc,
		v8cint32	x,
		v8cint32	y,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

p0  =  acc0  +  x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

p1  =  acc1  +  x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

p2  =  acc2  +  x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

p3  =  acc3  +  x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	acc	Direct accumulator values for a.

half_butterfly_dit_cj() [2/2]

v8cacc48 half_butterfly_dit_cj	(	v8cint32	x,
		v8cint32	y,
		unsigned int	aoffsets,
		unsigned int	boffsets,
		v8cint16	z,
		unsigned int	zstart,
		unsigned int	zoffsets,
		int	shft
	)

The butterfly function is the central calculation of the FFT algorithm. It takes two inputs that are to be acted upon as well as a set of twiddle values and performs the decimation-in-time (dit) FFT operation upon them. The offset values (aoffsets,boffsets,zoffsets) determine which inputs will interact with which twiddle values. This butterfly function performs the following pseudocode:

o0  =    x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

o1  =    x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

o2  =    x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

o3  =    x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

p0  =  ups(x::y(aoffsets0 ),shift) +  x::y(boffsets0 )*( conj(z) (zstart + zoffsets0 ));  

p1  =  ups(x::y(aoffsets1 ),shift) +  x::y(boffsets1 )*( conj(z) (zstart + zoffsets1 ));  

p2  =  ups(x::y(aoffsets2 ),shift) +  x::y(boffsets2 )*( conj(z) (zstart + zoffsets2 ));  

p3  =  ups(x::y(aoffsets3 ),shift) +  x::y(boffsets3 )*( conj(z) (zstart + zoffsets3 ));  

where,
x::y == concat(x, y)
For more information, see FFT intrinsics

Returns

Output accumulator register.

Parameters

[in]	x	First input buffer for FFT values.
[in]	y	Second input buffer for FFT values.
[in]	boffsets	Selects the values for b from x::y i.e., from the concatenated buffer of x and y.
[in]	z	Buffer of twiddle values.
[in]	zstart	Fixed offset to the twiddle value selectors. This must be a compile time constant.
[in]	zoffsets	Selects the twiddle values from z.
[in]	zconj	(Optional) twiddle values are conjugated befor multiplication.
[in]	aoffsets	Selects the values for a from x::y.
[in]	shft	Upshift value for the values from a before accumulation.