polylane 0.10.0

Portable and versatile SIMD.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Copyright 2025 Gabriel Bjørnager Jensen.
//
// This Source Code Form is subject to the terms of
// the Mozilla Public License, v. 2.0. If a copy of
// the MPL was not distributed with this file, you
// can obtain one at:
// <https://mozilla.org/MPL/2.0/>.

mod data_kind;

pub(crate) use data_kind::DataKind;

use crate::simd::{
	Simd,
	SimdScalar,
	Layout,
	ValidLayout,
};

/// Executes a native SIMD vector operation on a PolyLane SIMD vector type.
///
/// # Safety
///
/// `Simd<T, N>` must have the same size and alignement as `Native`.
/// `Native` must be a natively-supported SIMD vector type of `N` times `T` scalars.
#[inline(always)]
#[must_use]
#[track_caller]
pub(crate) unsafe fn exec_binary_native_simd_op<
	LhsScalar,
	RhsScalar,
	ResultScalar,
	LhsNative,
	RhsNative,
	ResultNative,
	F,
	const N: usize,
>(
	lhs: Simd<LhsScalar, N>,
	rhs: Simd<RhsScalar, N>,
	op: F,
) -> Simd<ResultScalar, N>
where
	LhsScalar:    SimdScalar,
	RhsScalar:    SimdScalar,
	ResultScalar: SimdScalar,
	LhsNative:    Copy,
	RhsNative:    Copy,
	ResultNative: Copy,
	F:            FnOnce(LhsNative, RhsNative) -> ResultNative,

	Layout<LhsScalar,    N>: ValidLayout,
	Layout<RhsScalar,    N>: ValidLayout,
	Layout<ResultScalar, N>: ValidLayout,

	Layout<bool, N>: ValidLayout,
{
	let is_same_sizes =
		size_of::<Simd<LhsScalar, N>>() == size_of::<LhsNative>()
		&& size_of::<Simd<RhsScalar, N>>() == size_of::<RhsNative>()
		&& size_of::<Simd<ResultScalar, N>>() == size_of::<ResultNative>();

	let is_same_aligns =
		align_of::<Simd<LhsScalar, N>>() == align_of::<LhsNative>()
		&& align_of::<Simd<RhsScalar, N>>() == align_of::<RhsNative>()
		&& align_of::<Simd<ResultScalar, N>>() == align_of::<ResultNative>();

	debug_assert!(is_same_sizes);
	debug_assert!(is_same_aligns);

	// FIXME: We would like to assert the above, but
	// for some reasons these cause panics even on
	// other code paths. Hopefully, this test will be
	// optimised away.
	if !is_same_sizes || !is_same_aligns {
		return Default::default();
	}

	let lhs = unsafe { *(&raw const lhs as *const LhsNative) };

	let rhs = unsafe { *(&raw const rhs as *const RhsNative) };

	let result = op(lhs, rhs);

	unsafe { *(&raw const result as *const Simd<ResultScalar, N>) }
}