BFMMLA (widening)

BFloat16 matrix multiply-accumulate to single-precision

If FEAT_EBF16 is not implemented or FPCR.EBF is 0, this instruction:

  • Performs two unfused sums-of-products within each two pairs of adjacent BFloat16 elements while multiplying the 2×4 matrix of BFloat16 values held in each 128-bit segment of the first source vector by the 4×2 matrix of BFloat16 values in the corresponding segment of the second source vector. The intermediate single-precision products are rounded before they are summed and the intermediate sum is rounded before accumulation into the 2×2 single-precision matrix in the corresponding segment of the destination vector. This is equivalent to accumulating two 2-way unfused dot products per destination element.
  • Uses the non-IEEE 754 Round-to-Odd rounding mode, which forces bit 0 of an inexact result to 1, and rounds an overflow to an appropriately signed Infinity.
  • Flushes denormalized inputs and results to zero, as if FPCR.{FZ, FIZ} is {1, 1}.
  • Honors FPCR.AH when generating a default NaN result, otherwise disables alternative floating point behaviors, as if FPCR.AH is 0.

    • If FEAT_EBF16 is implemented and FPCR.EBF is 1, then this instruction:

  • Performs two fused sums-of-products within each two pairs of adjacent BFloat16 elements while multiplying the 2×4 matrix of BFloat16 values held in each 128-bit segment of the first source vector by the 4×2 matrix of BFloat16 values in the corresponding segment of the second source vector. The intermediate single-precision products are not rounded before they are summed, but the intermediate sum is rounded before accumulation into the 2×2 single-precision matrix in the corresponding segment of the destination vector. This is equivalent to accumulating two 2-way fused dot products per destination element.
  • Follows all other floating-point behaviors that apply to single-precision arithmetic, as governed by FPCR.RMode, FPCR.FZ, FPCR.AH, and FPCR.FIZ.

    • Irrespective of FEAT_EBF16 and FPCR.EBF, this instruction:

  • Does not modify the cumulative FPSR exception bits (IDC, IXC, UFC, OFC, DZC, and IOC).
  • Disables trapped floating-point exceptions, as if the FPCR trap enable bits (IDE, IXE, UFE, OFE, DZE, and IOE) are all zero.
  • Generates only the default NaN, as if FPCR.DN is 1.

    • This instruction is unpredicated and vector length agnostic.

    ID_AA64ZFR0_EL1.BF16 indicates whether this instruction is implemented.

    This instruction is illegal when executed in Streaming SVE mode, unless FEAT_SME_FA64 is implemented and enabled.

    Encoding: SVE

    Variants: FEAT_SVE && FEAT_BF16 (FEAT_SVE && FEAT_BF16)

    313029282726252423222120191817161514131211109876543210
    01100100011111001
    opcZmZnZda

    BFMMLA <Zda>.S, <Zn>.H, <Zm>.H

    Decoding algorithm

    if !IsFeatureImplemented(FEAT_SVE) || !IsFeatureImplemented(FEAT_BF16) then
    EndOfDecode(Decode_UNDEF);
constant integer n = UInt(Zn);
constant integer m = UInt(Zm);
constant integer da = UInt(Zda);

    Operation

    CheckNonStreamingSVEEnabled();
constant integer VL = CurrentVL;
constant integer segments =  VL DIV 128;
constant bits(VL) operand1 = Z[n, VL];
constant bits(VL) operand2 = Z[m, VL];
constant bits(VL) operand3 = Z[da, VL];
bits(VL) result;
bits(128) op1, op2;
bits(128) res, addend;

for s = 0 to segments-1
    op1    = Elem[operand1, s, 128];
    op2    = Elem[operand2, s, 128];
    addend = Elem[operand3, s, 128];
    res    = BFMatMulAddH(addend, op1, op2,  FPCR);
    Elem[result, s, 128] = res;

Z[da, VL] = result;

    Explanations

    <Zda>: Is the name of the third source and destination scalable vector register, encoded in the "Zda" field.
    <Zn>: Is the name of the first source scalable vector register, encoded in the "Zn" field.
    <Zm>: Is the name of the second source scalable vector register, encoded in the "Zm" field.

    Operational Notes

    This instruction might be immediately preceded in program order by a MOVPRFX instruction. The MOVPRFX must conform to all of the following requirements, otherwise the behavior of the MOVPRFX and this instruction is CONSTRAINED UNPREDICTABLE: