WebAssembly SIMD review

[dtig]

Hello TAG!

I'm requesting a TAG review of WebAssembly SIMD.

• WASM CG Explainer: https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md
• Web Platform focused Explainer: https://github.com/WebAssembly/simd/blob/master/proposals/simd/W3CTAG-SIMDExplainer.md
• Proposal directory: https://github.com/WebAssembly/simd/tree/master/proposals/simd
• Example usage and demos: https://v8.dev/features/simd
• Tests: https://github.com/WebAssembly/simd/tree/master/test/core/simd
• Security and Privacy self-review: There are no known security or privacy impacts of this feature.
• GitHub repo: https://github.com/WebAssembly/simd
• Primary contacts:
  • Deepti Gandluri, @dtig, [Google]
  • Thomas Lively, @tlively, [Google]
  • Zhi An Ng, @ngzhian, [Google]
  • Arun Purushan, @arunetm, [Intel]
• External status/issue trackers for this feature:
  https://www.chromestatus.com/feature/6533147810332672

Further details:

• I have reviewed the TAG's API Design Principles
• The group where the incubation/design work on this is being done: WebAssembly Community Group
• The group where standardization of this work is intended to be done: WebAssembly Working Group

You should also know that...

This is purely a WebAssembly performance feature that does not affect web API behavior, but is still useful for developers to be aware of as it can change performance characteristics of applications using WebAssembly. It adds a new 128-bit value type that is not exposed to JavaScript and several new opcodes for vector operations that are documented here.

We'd prefer the TAG provide feedback as:

🐛 open issues in our GitHub repo for each point of feedback

[MattMenke2]

If a platform doesn't natively support the corresponding SIMD operations, we WebAssembly falls back to emulation, right? So with respect to CPU fingerprinting, you can probably figure out whether a system supports the corresponding SIMD operations by timing attacks, but that's it?

How much do CPUs vary in terms of support for these operations? Just want to know how many bits of CPU information we're exposing here.

[dtig]

If a platform doesn't have native support for SIMD operations, the engines can either choose to handle this with a Scalar fallback, or applications will need to deploy a WebAssembly binary that can be used as a fallback. Picking between two binaries depending on the feature being supported is a common feature detection model for WebAssembly.

The baseline assumption for the current SIMD proposal is that the operations have reasonable mappings to hardware instructions on most modern hardware. In this case, all Intel hardware that has SSE4.1+, as well as most modern ARM, MIPS LE hardware. With respect to CPU fingerprinting, it is possible to figure out whether a system supports the corresponding SIMD operations, but given that the current set of operations are a basic set of vector operations available on most modern hardware, this information may not be particularly useful.

One of the goals for the proposal is also that the performance of these operations should be portable across architectures i.e. a similar class of applications should see a performance boost on all supported architectures. That said with a select set of operations, and careful perf measurements, it may be possible to distinguish between Intel/ARM hardware, but this will also depend to a large extent on engine implementations (level of optimization, code generation support for advanced extensions like AVX on Intel etc.).

[kenchris]

Had a meeting with @arunetm where we discussed the TAG review, and how we review and what we expect.

We really would like a better explainer, geared toward landing the feature as part of the broader Web Paltform. The current one is really technical and written for the WASM CG and differs somewhat from what we are expecting.

Please read our explainer about explainers: https://w3ctag.github.io/explainers

For instance we would like a section about Considered Alternatives, which should list the SIMD.js work and why that was abandoned.

We would also like information about whether it would be possible to bring SIMD to JavaScript in the future so that WASM and JS don't diverge too much. Or whether that might not make sense.

Are there any current outstanding issues or disagreement that we should know about?

Is the proposal playing favors to some architectures or making sure that design is done in a way that different architectures can gain similar performance with optimized pipelines?

What is the plan for > 128 SIMD?