initial commit

Author: gnzlbg

Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "spmd"
+version = "0.1.0"
+authors = ["gnzlbg <[email protected]>"]
+
+[dependencies]

readme.md

@@ -0,0 +1,3 @@
+# `Simd<[T; N]>` - alternative fully-conforming implementation of `std::simd`
+
+> WIP

src/api/minimal_iuf.rs

@@ -0,0 +1,87 @@
+//! Minimal API of signed integer, unsigned integer, and floating-point vectors.
+
+macro_rules! impl_minimal_iuf {
+    ([$elem_ty:ident; $elem_count:expr]: $tuple_id:ident |
+     $($elem_name:ident),+ |
+     $(#[$doc:meta])*) => {
+
+        $(#[$doc])*
+        pub type $tuple_id = Simd<[$elem_ty; $elem_count]>;
+
+        impl Simd<[$elem_ty; $elem_count]> {
+            /// Creates a new instance with each vector elements initialized
+            /// with the provided values.
+            #[inline]
+            pub const fn new($($elem_name: $elem_ty),*) -> Self {
+                Simd(sealed::$tuple_id($($elem_name),*))
+            }
+
+            /// Returns the number of vector lanes.
+            #[inline]
+            pub const fn lanes() -> usize {
+                $elem_count
+            }
+
+            /// Constructs a new instance with each element initialized to
+            /// `value`.
+            #[inline]
+            pub const fn splat(value: $elem_ty) -> Self {
+                Simd(sealed::$tuple_id($({
+                    #[allow(non_camel_case_types, dead_code)]
+                    struct $elem_name;
+                    value
+                }),*))
+            }
+
+            /// Extracts the value at `index`.
+            ///
+            /// # Panics
+            ///
+            /// If `index >= Self::lanes()`.
+            #[inline]
+            pub fn extract(self, index: usize) -> $elem_ty {
+                assert!(index < $elem_count);
+                unsafe { self.extract_unchecked(index) }
+            }
+
+            /// Extracts the value at `index`.
+            ///
+            /// # Precondition
+            ///
+            /// If `index >= Self::lanes()` the behavior is undefined.
+            #[inline]
+            pub unsafe fn extract_unchecked(self, index: usize) -> $elem_ty {
+                use llvm::simd_extract;
+                simd_extract(self.0, index as u32)
+            }
+
+            /// Returns a new vector where the value at `index` is replaced by `new_value`.
+            ///
+            /// # Panics
+            ///
+            /// If `index >= Self::lanes()`.
+            #[inline]
+            #[must_use = "replace does not modify the original value - it returns a new vector with the value at `index` replaced by `new_value`d"]
+            pub fn replace(self, index: usize, new_value: $elem_ty) -> Self {
+                assert!(index < $elem_count);
+                unsafe { self.replace_unchecked(index, new_value) }
+            }
+
+            /// Returns a new vector where the value at `index` is replaced by `new_value`.
+            ///
+            /// # Precondition
+            ///
+            /// If `index >= Self::lanes()` the behavior is undefined.
+            #[inline]
+            #[must_use = "replace_unchecked does not modify the original value - it returns a new vector with the value at `index` replaced by `new_value`d"]
+            pub unsafe fn replace_unchecked(
+                self,
+                index: usize,
+                new_value: $elem_ty,
+            ) -> Self {
+                use llvm::simd_insert;
+                Simd(simd_insert(self.0, index as u32, new_value))
+            }
+        }
+    }
+}

src/api/mod.rs

@@ -0,0 +1,26 @@
+#[macro_use]
+mod minimal_iuf;
+
+macro_rules! impl_i {
+    ([$elem_ty:ident; $elem_count:expr]: $tuple_id:ident
+     | $($elem_ids:ident),* | $(#[$doc:meta])*) => {
+        impl_minimal_iuf!([$elem_ty; $elem_count]: $tuple_id
+                          | $($elem_ids),* | $(#[$doc])*);
+    }
+}
+
+macro_rules! impl_u {
+    ([$elem_ty:ident; $elem_count:expr]: $tuple_id:ident
+     | $($elem_ids:ident),* | $(#[$doc:meta])*) => {
+        impl_minimal_iuf!([$elem_ty; $elem_count]: $tuple_id
+                          | $($elem_ids),* | $(#[$doc])*);
+    }
+}
+
+macro_rules! impl_f {
+    ([$elem_ty:ident; $elem_count:expr]: $tuple_id:ident
+     | $($elem_ids:ident),* | $(#[$doc:meta])*) => {
+        impl_minimal_iuf!([$elem_ty; $elem_count]: $tuple_id
+                          | $($elem_ids),* | $(#[$doc])*);
+    }
+}

src/lib.rs

@@ -0,0 +1,31 @@
+//! SPMD - Single Program Multiple Data
+#![feature(repr_simd, const_fn, platform_intrinsics)]
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]  // FIXME: remove this allow
+
+mod llvm;
+mod sealed;
+#[macro_use]
+mod api;
+
+/// SIMD vector type
+///
+/// # Examples
+///
+/// ```
+/// # use spmd::Simd;
+/// let v = Simd::<[i32; 4]>::new(0, 1, 2, 3);
+/// assert_eq!(v.extract(2), 2);
+/// ```
+#[derive(Copy, Clone)]
+pub struct Simd<A: sealed::SimdArray>(<A as sealed::SimdArray>::Tuple);
+
+impl_i!([i32; 4]: i32x4 | x0, x1, x2, x3 |
+        /// A 128-bit vector with 4 `i32` lanes.
+);
+impl_u!([u32; 4]: u32x4 | x0, x1, x2, x3 |
+        /// A 128-bit vector with 4 `u32` lanes.
+);
+impl_f!([f32; 4]: f32x4 | x0, x1, x2, x3 |
+        /// A 128-bit vector with 4 `f32` lanes.
+);

src/llvm.rs

@@ -0,0 +1,55 @@
+//! LLVM's simd platform intrinsics
+
+extern "platform-intrinsic" {
+    pub fn simd_eq<T, U>(x: T, y: T) -> U;
+    pub fn simd_ne<T, U>(x: T, y: T) -> U;
+    pub fn simd_lt<T, U>(x: T, y: T) -> U;
+    pub fn simd_le<T, U>(x: T, y: T) -> U;
+    pub fn simd_gt<T, U>(x: T, y: T) -> U;
+    pub fn simd_ge<T, U>(x: T, y: T) -> U;
+
+    pub fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U;
+    pub fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U;
+    pub fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U;
+    pub fn simd_shuffle16<T, U>(x: T, y: T, idx: [u32; 16]) -> U;
+    pub fn simd_shuffle32<T, U>(x: T, y: T, idx: [u32; 32]) -> U;
+
+    pub fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
+    pub fn simd_extract<T, U>(x: T, idx: u32) -> U;
+
+    pub fn simd_cast<T, U>(x: T) -> U;
+
+    pub fn simd_add<T>(x: T, y: T) -> T;
+    pub fn simd_sub<T>(x: T, y: T) -> T;
+    pub fn simd_mul<T>(x: T, y: T) -> T;
+    pub fn simd_div<T>(x: T, y: T) -> T;
+    pub fn simd_rem<T>(x: T, y: T) -> T;
+    pub fn simd_shl<T>(x: T, y: T) -> T;
+    pub fn simd_shr<T>(x: T, y: T) -> T;
+    pub fn simd_and<T>(x: T, y: T) -> T;
+    pub fn simd_or<T>(x: T, y: T) -> T;
+    pub fn simd_xor<T>(x: T, y: T) -> T;
+
+    pub fn simd_reduce_add_unordered<T, U>(x: T) -> U;
+    pub fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
+    pub fn simd_reduce_add_ordered<T, U>(x: T, acc: U) -> U;
+    pub fn simd_reduce_mul_ordered<T, U>(x: T, acc: U) -> U;
+    pub fn simd_reduce_min<T, U>(x: T) -> U;
+    pub fn simd_reduce_max<T, U>(x: T) -> U;
+    pub fn simd_reduce_min_nanless<T, U>(x: T) -> U;
+    pub fn simd_reduce_max_nanless<T, U>(x: T) -> U;
+    pub fn simd_reduce_and<T, U>(x: T) -> U;
+    pub fn simd_reduce_or<T, U>(x: T) -> U;
+    pub fn simd_reduce_xor<T, U>(x: T) -> U;
+    pub fn simd_reduce_all<T>(x: T) -> bool;
+    pub fn simd_reduce_any<T>(x: T) -> bool;
+
+    pub fn simd_select<M, T>(m: M, a: T, b: T) -> T;
+
+    pub fn simd_fmin<T>(a: T, b: T) -> T;
+    // FIXME: https://github.com/rust-lang-nursery/stdsimd/issues/416
+    // pub fn simd_fmax<T>(a: T, b: T) -> T;
+
+    pub fn simd_fsqrt<T>(a: T) -> T;
+    pub fn simd_fma<T>(a: T, b: T, c: T) -> T;
+}

src/sealed.rs

@@ -0,0 +1,26 @@
+//! Sealed traits
+
+/// Trait implemented by arrays that can be SIMD types
+pub trait SimdArray {
+    type Tuple: Copy + Clone;
+    type T;
+    const N: usize;
+}
+
+macro_rules! impl_simd_array {
+    ([$elem_ty:ident; $elem_cnt:expr]: $tuple_id:ident | $($elem_tys:ident),*) => {
+        #[derive(Copy, Clone)]
+        #[repr(simd)]
+        pub struct $tuple_id($(pub $elem_tys),*);
+
+        impl SimdArray for [$elem_ty; $elem_cnt] {
+            type Tuple = $tuple_id;
+            type T = $elem_ty;
+            const N: usize = $elem_cnt;
+        }
+    }
+}
+
+impl_simd_array!([i32; 4]: i32x4 | i32, i32, i32, i32);
+impl_simd_array!([u32; 4]: u32x4 | u32, u32, u32, u32);
+impl_simd_array!([f32; 4]: f32x4 | f32, f32, f32, f32);