Data Types - Data Types - 2026.1 English - UG1603

Vector Based Floating-point Data Types

As shown in the table, the FP16 and BF16 use 16 bits, but their allocation differs. BF16 prioritizes range, assigning 8 bits to the exponent, while FP16 prioritizes precision by allocating 10 bits to the mantissa.

Block Floating-point Data Types

Block-floating-point data types, also known as MX data types, represent a set of 16 floating-point numbers. These 16 numbers share a common 8-bit level 1 exponent, and eight 1-bit level-2 exponents, shared between a pair of mantissas. Each number has one sign bit and a mantissa composed of an explicit integer bit and one or more fractional bits. There are three different data types of varying mantissa bit widths referenced as MX9, MX6, and MX4. The following figure and table details these data types.

Figure 2. MX Datatype Elements

Depending on the type of the block floating-point, the mantissa size is different:

In a block floating-point number, 16 values are represented. The i^th number value is computed as follows: x(i) = (-1)^Sign(i)*Mantissa(i)*2^{(E1 - 128 - E2([i/2])} where:

Sign(i)

Sign bit of the i^th number

Mantissa(i)

Mantissa of the i^th number

E1

Level 1 exponent

E2([i/2])

Level 2 exponent of the i^th number where [i/2] indicates the index of the corresponding pair to which the number is associated

As shown in the preceding figures, 16 MX9 data are packed into 18 bytes. On average, an MX9 block-floating-point number occupies 9 bits.

Equivalently 16 MX6 data are packed in 12 bytes and 16 MX4 data are packed in 8 bytes.

aie::block_vector<mx9,VectorSize> v;
aie::block_vector<mx6,VectorSize> v;
aie::block_vector<mx4,VectorSize> v;

There is no padding in memory. That is why you cannot access these data using simple vector iterators as for standard data type, but specific block_vector_buffer_stream. Refer to Block Floating-Point Buffer Stream.

Accumulator Data Types

An accumulator represents a collection of elements of the same class, typically resulting from multiplication operations. Accumulators map to the corresponding accumulator registers supported on each architecture. Compared to typical vector types, accumulators often possess a larger number of bits. This enables the efficient execution of long chains of operations where intermediate results potentially exceed the range of standard vectors. Accumulators are parameterized by their element type, and the number of elements they contain.

Complex accumulators (prefixed by "c"), require twice the number of native accumulation bits: one for the real part and another one for the imaginary part.

The AI Engine API automatically maps accumulator types to the closest native accumulator type supported by the target architecture. For example, acc48 maps to acc64 on the AI Engine-ML architecture.

aie::vector and aie::accum objects offer member functions for type casting, data extraction, insertion, and indexing. However, a limited subset of accumulator data types is supported for interfaces within the graph code. For details, refer to Stream and Cascade Data Types.

For more information on streams, refer to Streaming Data API.