The LX2 core, and 128 flops a cycle

Two compute dies, four clusters per die. Chips and Cheese reports 40 physical cores per cluster with two fused off, which leaves 38 active, 152 per die and 304 per socket. Fusing cores is the usual yield trick on a big die, and it fits a chip that is probably built on a domestic 7 nm class process (that last part is speculation from The Next Platform).

The L2 is large: 28.5 MB for 38 cores is 750 KB per core, shared inside the cluster. There is no L3 in any source. The on-package HBM plays that role, one stack per cluster.

The FP64 peak of a socket is 60.3 TFlop/s. Divide by cores and clock:

A 512-bit SVE unit holds 8 doubles. With two FMA pipes that is 2 × 8 × 2 = 32 flops per cycle, a quarter of the peak. The rest comes from SME, the Scalable Matrix Extension. Each core has one 512-bit SME engine, and its FMOPA instruction takes two vectors of 8 doubles and adds their outer product into an 8 × 8 tile of accumulators called ZA. That is 64 FMAs, or 128 flops, every cycle.

The other precisions scale as you would expect from a 512-bit datapath:

The per-cycle column is mine: peak divided by 304 × 1.55 GHz.

1.55 GHz is low for a 2026 server core. But a socket at 690 W running 304 matrix engines spends its power on the datapath, not on frequency. Per watt at the socket, the FP64 peak is 60.3 TFlop/s / 690 W ≈ 87 GFlop/s per W, which is in the range of a GPU. The clock is the price of that.

SME only pays off on code shaped like a matrix product: dense GEMM, the panels of an LU or Cholesky factorisation, batched small matrices, convolutions written as GEMM, attention. HPL is exactly that, which is why LineShine posts 80% of peak.

Code that the compiler vectorises with SVE, a loop over arrays with no reuse, gets at most 32 of the 128 flops per cycle. And most such code is memory-bound anyway, so it never gets near SVE's limit either. The memory page has the numbers.

Writing SME by hand is unusual. The arXiv teams that trained models on LineShine wrote two GEMM micro-kernels, 64 × K by K × 16 and 16 × K by K × 64, and picked one at run time from the matrix shape. The blocking depth K is derived from the L2 size. Everything else calls a BLAS that already knows SME, which on this machine means Huawei's Kunpeng Math Library.