Make explicit (documented) promises about layout of vector types?

[danderson]

To implement FastLanes, I'm defining a 1024-bit simd vector type. This is quite easy to do with something like:

#[repr(C, align(64))]
struct Chunk(u64x8, u64x8);

To implement stuff like as_slice on this, I can unsafely convert &self to a &[u8] of the correct length, because u64x8 is also repr(C) and the alignment guarantees that there's no padding.

But afaict fearless_simd doesn't currently promise anything about the layout of these types, so I can't be certain that it'll keep working in future (although it seems unlikely to change). Could fearless_simd document some guarantees about those types? Maybe something like this, for all SimdBase types:

• size_of::<T>() == size_of::<T::Array>()
• align_of::<T>() >= align_of::<T::Element>() (codegen currently makes this == on the published type, but I think the arch-specific intrinsic types inside might force larger alignment on some platforms?)

[Shnatsel]

Good call! We should document that. I believe the alignment is even greater right now, but I'll need to double-check before committing to it.

The types are plain old data with no padding.

You can const-assert size and alignment like this, so you get a compile error if the contract is ever violated:

fearless_simd/fearless_simd/src/transmute.rs

Lines 334 to 346 in 54fbd62

	const {
	assert!(
	size_of::<Src>() == size_of::<Dst>(),
	"checked_cast_mut requires source and destination to have the same size"
	);
	// alignment is always a power of two as per Rust Reference:
	// https://doc.rust-lang.org/stable/reference/type-layout.html#size-and-alignment
	// so >= is sufficient and won't run into issues with coprime alignments
	assert!(
	align_of::<Src>() >= align_of::<Dst>(),
	"checked_cast_mut requires source to have alignment equal or greater to the destination"
	);
	}