SVE and SME on AArch64

[nikomatsakis]

Metadata
Point of contact	@davidtwco
Team(s)	compiler, lang, types
Goal document	2025h1/arm-sve-sme

Summary

Over the next six months, we will aim to merge nightly support for SVE and establish a path
towards stabilisation:

• propose language changes which will enable scalable vector types to be represented in Rust's
  type system
• land an experimental nightly implementation of SVE
• identify remaining blockers for SVE stabilisation and plan their resolution
• gain a better understanding of SME's implications for Rust and identify first steps towards design
  and implementation

Tasks and status

• Discussion and moral support (lang, types, compiler )

Land nightly experiment for SVE types

• Land nightly experiment for SVE types (@JamieCunliffe)
• Author RFC
• RFC decision (types )
• Implementation
• Standard reviews (compiler )

Upstream SVE types and intrinsics

• Upstream SVE types and intrinsics (@JamieCunliffe)

Extending type system to support scalable vectors

• Extending type system to support scalable vectors (@davidtwco)
• Author RFC
• Lang-team champion (lang )
• RFC decision (types, lang )
• Implementation
• Standard reviews (compiler )

Investigate SME support

• Investigate SME support (@JamieCunliffe, @davidtwco)
• Discussion and moral support (lang, types, compiler )
• Draft next goal (@davidtwco)

[nikomatsakis]

This issue is intended for status updates only.

For general questions or comments, please contact the owner(s) directly.

[davidtwco]

An initial update on what we've been up to and some background:

• This goal is submitted on behalf of the Rust team at Arm, but primarily worked on by myself (@davidtwco) and @JamieCunliffe. Anyone interested can always contact me for updates and I'll keep this issue up-to-date.
• @JamieCunliffe been working on supporting Arm's scalable vector extension (SVE) for a couple years - primarily in RFC: Add a scalable representation to allow support for scalable vectors rfcs#3268 and its implementation Support for a scalable simd representation rust#118917.
  • Through this work, we've discovered other changes to the language necessary to be able to support these types without special cases in the type system, which we're also working on (see below).
  • Jamie is still resolving feedback on this RFC and its implementation, and keeping it rebased. We hope that it can be landed experimentally now that there's a feasible path to remove the special cases in the type system (see below).
  • The next steps for this RFC and implementation are..
    • ..to continue to respond to feedback on the RFC and implementation.
• I've (@davidtwco) been working on Hierarchy of Sized traits rfcs#3729 which improves Rust's support for exotically sized types, and would allow scalable vectors to be represented in the type system without special cases.
  • We've had two design meetings with the language team about the RFC and had a broadly positive reception.
    • There is a non-strict dependency on const traits (Make trait methods callable in const contexts rfcs#3762) which has created uncertainty as to whether this RFC could be accepted without the specifics of const traits being nailed down.
  • I've been working on implementing the RFC: an initial implementation of the non-const traits has been completed and adding the const traits is in-progress.
    • The language team have indicated interest in seeing this land experimentally, but this will depend on whether the implementors of const traits are okay with this, as it would add to the work they need to do to make any syntactic changes requested by the language team in Make trait methods callable in const contexts rfcs#3762.
  • I'm continuing to respond to feedback on the RFC, but as this has largely trailed off, the next steps for this RFC are..
    • ..for the language team to decide to accept, reject, or request further changes to the RFC.
    • ..for progress on the implementation to continue.

[davidtwco]

A small update, we've opened a draft PR for the initial implementation of this - rust-lang/rust#137944. Otherwise, just continued to address feedback on the RFCs.

[davidtwco]

• We've been resolving review feedback on the implementation of the Sized Hierarchy RFC on Sized Hierarchy: Part I rust#137944. We're also working on reducing the performance regression in the PR, by avoiding unnecessary elaboration of sizedness supertraits and extending the existing Sized case in type_op_prove_predicate query's fast path.
• There's not been any changes to the RFC, there's minor feedback that has yet to be responded to, but it's otherwise just waiting on t-lang.
• We've been experimenting with rebasing Support for a scalable simd representation rust#118917 on top of Sized Hierarchy: Part I rust#137944 to confirm that const sizedness allows us to remove the type system exceptions that the SVE implementation previously relied on. We're happy to confirm that it does.

[davidtwco]

• We've resolved a handful of rounds of feedback on Sized Hierarchy: Part I rust#137944 from @oli-obk, @lcnr and @fee1-dead; resolved issues from a crater run (bar one); and worked to decrease the performance regression.
  • We've removed the constness parts of the patch to make it smaller and easier to review. Constness will come in a Part II.
  • There's currently a -1% mean regression (min 0.1%, max 5.3%) that we're working to improve, but starting to run out of ideas. Regressions are just a consequence of the compiler having to prove more things with the addition of MetaSized bounds, rather than hot spots in newly introduced code.
  • Given the large impact of the change, we ran a crater run and found three distinct issues, two have been fixed. The remaining issue is a overflow in a single niche crate which we're working out how we can resolve.
  • We're largely just waiting on hearing from our reviewers what would be needed to see this change land.
• We've not made any changes to the Sized Hierarchy RFC, there's a small amount of discussion which will be responded to once the implementation has landed.
• We're working on changes to the SVE RFC which further clarifies that the language changes are decided by the Sized RFC and that the SVE RFC is only proposing the forever-unstable repr(scalable) attribute which are non-const Sized and lower to vscale in LLVM.