add trait ScalarComposite

[Firestar99]

Requires #440

rust-gpu/crates/spirv-std/src/scalar_or_vector.rs

Lines 22 to 49 in 6db1894

	/// A `ScalarComposite` is a type that is either
	/// * a [`Scalar`]
	/// * a [`Vector`] (since vectors are made from scalars)
	/// * an array of `ScalarComposite`
	/// * a struct where all members are `ScalarComposite`
	/// * an enum with a `repr` that is a [`Scalar`]
	///
	/// By calling [`Self::transform`] you can visit all the individual [`Scalar`] and [`Vector`] values this composite is
	/// build out of and transform them into some other value. This is particularly useful for subgroup intrinsics sending
	/// data to other threads.
	///
	/// To derive `ScalarComposite` on a struct, all members must also implement `ScalarComposite`.
	///
	/// To derive `ScalarComposite` on an enum, the enum must implement `From<N>` and `Into<N>` where `N` is defined by the
	/// `#[repr(N)]` attribute on the enum and must be an [`Integer`], like `u32`.
	/// Note that some [safe subgroup operations] may return an "undefined result", so your `From<N>` must gracefully handle
	/// arbitrary bit patterns being passed to it. While panicking is legal, it is discouraged as it may result in
	/// unexpected control flow.
	/// To implement these conversion traits, we recommend [`FromPrimitive`] and [`IntoPrimitive`] from the [`num_enum`]
	/// crate. [`FromPrimitive`] requires the enum to either be exhaustive or have a variant to default to, by either
	/// implementing [`Default`] or marking a variant with `#[num_enum(default)]`. Note to disable default
	/// features on the [`num_enum`] crate, or it won't compile on SPIR-V.
	///
	/// [`Integer`]: crate::Integer
	/// [safe subgroup operations]: crate::arch::subgroup_shuffle
	/// [`FromPrimitive`]: https://docs.rs/num_enum/latest/num_enum/derive.FromPrimitive.html
	/// [`IntoPrimitive`]: https://docs.rs/num_enum/latest/num_enum/derive.IntoPrimitive.html
	/// [`num_enum`]: https://crates.io/crates/num_enum

Also see previous iteration at #411

todo

• derive enums
• subgroup_all_equal()
• subgroup_broadcast_const added in subgroup: fix docs and broadcast const variant #443

close#410

[nazar-pc]

Interesting, assuming this is zero cost abstraction (like when a struct contains a single scalar field I expect it to compile to the same code as if it was just a single scalar), this makes sense to me.

One opaque thing I do not like as much is that it can implicitly result in multiple subgroup operations. For example like when array is used it'll clearly iterate over each individual value instead of calling a vector form with all or part of the values, which may not be what the user would expect to happen.

[Firestar99]

assuming this is zero cost abstraction

Pretty much, otherwise you'd see the subgroup compiletests with disassembly fail due to different codegen.

it can implicitly result in multiple subgroup operations

If you can't observe the difference between a single operation and multiple operations back-to-back, does that actually matter?
Also, you can expect all modern hardware to decompose any kind of vector op into multiple scalar ops, so us emitting actual vector ops won't give us any real benefit. Apart from maybe saving a few bytes of shader IR.

[LegNeato]

Going to let @eddyb review

[Firestar99]

I'm surprised you say that, since this is only changing some ordinary rust code in spirv-std, defining that new trait and providing a derive for it. I didn't change any of the spirv intrinsics themselves.

[nazar-pc]

I'd love for this to land, it'll make a few places in my code much less awkward

[Firestar99]

Thought: shorten the name to ScalarComposite. Vectors are made from scalars, so it is still correctly named.

[eddyb]

Neat approach, impl seems correct (add ?w=1 to the GitHub URL hide whitespace changes), we should land this if there aren't design concerns.

(to be honest I didn't even realize this was blocked on me)