polylane 0.12.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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// 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::{
	Layout,
	Simd,
	SimdScalar,
	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.
#[allow(unused)]
#[inline(always)]
#[must_use]
#[track_caller]
pub(crate) unsafe fn exec_unary_native_simd_op<
	InputScalar,
	OutputScalar,
	InputNative,
	OutputNative,
	F,
	const N: usize,
>(
	input: Simd<InputScalar, N>,
	op:    F,
) -> Simd<OutputScalar, N>
where
	InputScalar:  SimdScalar,
	OutputScalar: SimdScalar,
	InputNative:  Copy,
	OutputNative: Copy,
	F:            FnOnce(InputNative) -> OutputNative,

	Layout<InputScalar,  N>: ValidLayout,
	Layout<OutputScalar, N>: ValidLayout,

	Layout<(), N>: ValidLayout,
{
	let is_same_sizes =
		size_of::<Simd<InputScalar, N>>() == size_of::<InputNative>()
		&& size_of::<Simd<OutputScalar, N>>() == size_of::<OutputNative>();

	let is_same_aligns =
		align_of::<Simd<InputScalar, N>>() == align_of::<InputNative>()
		&& align_of::<Simd<OutputScalar, N>>() == align_of::<OutputNative>();

	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 input = unsafe { *(&raw const input as *const InputNative) };

	let result = op(input);

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

/// 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.
#[allow(unused)]
#[inline(always)]
#[must_use]
#[track_caller]
pub(crate) unsafe fn exec_binary_native_simd_op<
	LhsScalar,
	RhsScalar,
	OutputScalar,
	LhsNative,
	RhsNative,
	OutputNative,
	F,
	const N: usize,
>(
	lhs: Simd<LhsScalar, N>,
	rhs: Simd<RhsScalar, N>,
	op:  F,
) -> Simd<OutputScalar, N>
where
	LhsScalar:    SimdScalar,
	RhsScalar:    SimdScalar,
	OutputScalar: SimdScalar,
	LhsNative:    Copy,
	RhsNative:    Copy,
	OutputNative: Copy,
	F:            FnOnce(LhsNative, RhsNative) -> OutputNative,

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

	Layout<(), 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<OutputScalar, N>>() == size_of::<OutputNative>();

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

	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<OutputScalar, N>) }
}