Merge pull request rust-lang#152 from rust-lang/feature/const_eval_checked

Feature/const eval checked
Adds the const_evaluatable_checked cargo feature for some experimental (but very useful) function implementations. Adds testing all cargo features to CI.

Author: workingjubilee

.github/workflows/ci.yml

@@ -196,3 +196,28 @@ jobs:
       - name: Test (release)
         run: cross test --verbose --target=${{ matrix.target }} --release
 
+  features:
+    name: "Check cargo features (${{ matrix.features }} ${{ matrix.rustflags }})"
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rustflags:
+          - ""
+          - "-Ctarget-feature=+avx512" # AVX-512 uses packed bit masks, so enable it to test more code paths
+        features:
+          - ""
+          - "--features std"
+          - "--features const_evaluatable_checked"
+          - "--features std --features const_evaluatable_checked"
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Rust
+        run: |
+          rustup update nightly --no-self-update
+          rustup default nightly
+      - name: Check build
+        run: cargo check --all-targets --no-default-features ${{ matrix.features }}
+        env:
+            RUSTFLAGS: ${{ matrix.rustflags }}

crates/core_simd/Cargo.toml

@@ -10,8 +10,9 @@ categories = ["hardware-support", "no-std"]
 license = "MIT OR Apache-2.0"
 
 [features]
-default = ["std"]
+default = ["std", "const_evaluatable_checked"]
 std = []
+const_evaluatable_checked = []
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies.wasm-bindgen]
 version = "0.2"

crates/core_simd/examples/nbody.rs

@@ -1,169 +1,173 @@
-#![feature(portable_simd)]
+#![cfg_attr(feature = "std", feature(portable_simd))]
 
 /// Benchmarks game nbody code
 /// Taken from the `packed_simd` crate
 /// Run this benchmark with `cargo test --example nbody`
-use core_simd::*;
+#[cfg(feature = "std")]
+mod nbody {
+    use core_simd::*;
 
-use std::f64::consts::PI;
-const SOLAR_MASS: f64 = 4.0 * PI * PI;
-const DAYS_PER_YEAR: f64 = 365.24;
+    use std::f64::consts::PI;
+    const SOLAR_MASS: f64 = 4.0 * PI * PI;
+    const DAYS_PER_YEAR: f64 = 365.24;
 
-#[derive(Debug, Clone, Copy)]
-pub struct Body {
-    pub x: f64x4,
-    pub v: f64x4,
-    pub mass: f64,
-}
+    #[derive(Debug, Clone, Copy)]
+    struct Body {
+        pub x: f64x4,
+        pub v: f64x4,
+        pub mass: f64,
+    }
 
-const N_BODIES: usize = 5;
-const BODIES: [Body; N_BODIES] = [
-    // sun:
-    Body {
-        x: f64x4::from_array([0., 0., 0., 0.]),
-        v: f64x4::from_array([0., 0., 0., 0.]),
-        mass: SOLAR_MASS,
-    },
-    // jupiter:
-    Body {
-        x: f64x4::from_array([
-            4.84143144246472090e+00,
-            -1.16032004402742839e+00,
-            -1.03622044471123109e-01,
-            0.,
-        ]),
-        v: f64x4::from_array([
-            1.66007664274403694e-03 * DAYS_PER_YEAR,
-            7.69901118419740425e-03 * DAYS_PER_YEAR,
-            -6.90460016972063023e-05 * DAYS_PER_YEAR,
-            0.,
-        ]),
-        mass: 9.54791938424326609e-04 * SOLAR_MASS,
-    },
-    // saturn:
-    Body {
-        x: f64x4::from_array([
-            8.34336671824457987e+00,
-            4.12479856412430479e+00,
-            -4.03523417114321381e-01,
-            0.,
-        ]),
-        v: f64x4::from_array([
-            -2.76742510726862411e-03 * DAYS_PER_YEAR,
-            4.99852801234917238e-03 * DAYS_PER_YEAR,
-            2.30417297573763929e-05 * DAYS_PER_YEAR,
-            0.,
-        ]),
-        mass: 2.85885980666130812e-04 * SOLAR_MASS,
-    },
-    // uranus:
-    Body {
-        x: f64x4::from_array([
-            1.28943695621391310e+01,
-            -1.51111514016986312e+01,
-            -2.23307578892655734e-01,
-            0.,
-        ]),
-        v: f64x4::from_array([
-            2.96460137564761618e-03 * DAYS_PER_YEAR,
-            2.37847173959480950e-03 * DAYS_PER_YEAR,
-            -2.96589568540237556e-05 * DAYS_PER_YEAR,
-            0.,
-        ]),
-        mass: 4.36624404335156298e-05 * SOLAR_MASS,
-    },
-    // neptune:
-    Body {
-        x: f64x4::from_array([
-            1.53796971148509165e+01,
-            -2.59193146099879641e+01,
-            1.79258772950371181e-01,
-            0.,
-        ]),
-        v: f64x4::from_array([
-            2.68067772490389322e-03 * DAYS_PER_YEAR,
-            1.62824170038242295e-03 * DAYS_PER_YEAR,
-            -9.51592254519715870e-05 * DAYS_PER_YEAR,
-            0.,
-        ]),
-        mass: 5.15138902046611451e-05 * SOLAR_MASS,
-    },
-];
+    const N_BODIES: usize = 5;
+    const BODIES: [Body; N_BODIES] = [
+        // sun:
+        Body {
+            x: f64x4::from_array([0., 0., 0., 0.]),
+            v: f64x4::from_array([0., 0., 0., 0.]),
+            mass: SOLAR_MASS,
+        },
+        // jupiter:
+        Body {
+            x: f64x4::from_array([
+                4.84143144246472090e+00,
+                -1.16032004402742839e+00,
+                -1.03622044471123109e-01,
+                0.,
+            ]),
+            v: f64x4::from_array([
+                1.66007664274403694e-03 * DAYS_PER_YEAR,
+                7.69901118419740425e-03 * DAYS_PER_YEAR,
+                -6.90460016972063023e-05 * DAYS_PER_YEAR,
+                0.,
+            ]),
+            mass: 9.54791938424326609e-04 * SOLAR_MASS,
+        },
+        // saturn:
+        Body {
+            x: f64x4::from_array([
+                8.34336671824457987e+00,
+                4.12479856412430479e+00,
+                -4.03523417114321381e-01,
+                0.,
+            ]),
+            v: f64x4::from_array([
+                -2.76742510726862411e-03 * DAYS_PER_YEAR,
+                4.99852801234917238e-03 * DAYS_PER_YEAR,
+                2.30417297573763929e-05 * DAYS_PER_YEAR,
+                0.,
+            ]),
+            mass: 2.85885980666130812e-04 * SOLAR_MASS,
+        },
+        // uranus:
+        Body {
+            x: f64x4::from_array([
+                1.28943695621391310e+01,
+                -1.51111514016986312e+01,
+                -2.23307578892655734e-01,
+                0.,
+            ]),
+            v: f64x4::from_array([
+                2.96460137564761618e-03 * DAYS_PER_YEAR,
+                2.37847173959480950e-03 * DAYS_PER_YEAR,
+                -2.96589568540237556e-05 * DAYS_PER_YEAR,
+                0.,
+            ]),
+            mass: 4.36624404335156298e-05 * SOLAR_MASS,
+        },
+        // neptune:
+        Body {
+            x: f64x4::from_array([
+                1.53796971148509165e+01,
+                -2.59193146099879641e+01,
+                1.79258772950371181e-01,
+                0.,
+            ]),
+            v: f64x4::from_array([
+                2.68067772490389322e-03 * DAYS_PER_YEAR,
+                1.62824170038242295e-03 * DAYS_PER_YEAR,
+                -9.51592254519715870e-05 * DAYS_PER_YEAR,
+                0.,
+            ]),
+            mass: 5.15138902046611451e-05 * SOLAR_MASS,
+        },
+    ];
 
-pub fn offset_momentum(bodies: &mut [Body; N_BODIES]) {
-    let (sun, rest) = bodies.split_at_mut(1);
-    let sun = &mut sun[0];
-    for body in rest {
-        let m_ratio = body.mass / SOLAR_MASS;
-        sun.v -= body.v * m_ratio;
+    fn offset_momentum(bodies: &mut [Body; N_BODIES]) {
+        let (sun, rest) = bodies.split_at_mut(1);
+        let sun = &mut sun[0];
+        for body in rest {
+            let m_ratio = body.mass / SOLAR_MASS;
+            sun.v -= body.v * m_ratio;
+        }
     }
-}
 
-pub fn energy(bodies: &[Body; N_BODIES]) -> f64 {
-    let mut e = 0.;
-    for i in 0..N_BODIES {
-        let bi = &bodies[i];
-        e += bi.mass * (bi.v * bi.v).horizontal_sum() * 0.5;
-        for bj in bodies.iter().take(N_BODIES).skip(i + 1) {
-            let dx = bi.x - bj.x;
-            e -= bi.mass * bj.mass / (dx * dx).horizontal_sum().sqrt()
+    fn energy(bodies: &[Body; N_BODIES]) -> f64 {
+        let mut e = 0.;
+        for i in 0..N_BODIES {
+            let bi = &bodies[i];
+            e += bi.mass * (bi.v * bi.v).horizontal_sum() * 0.5;
+            for bj in bodies.iter().take(N_BODIES).skip(i + 1) {
+                let dx = bi.x - bj.x;
+                e -= bi.mass * bj.mass / (dx * dx).horizontal_sum().sqrt()
+            }
         }
+        e
     }
-    e
-}
 
-pub fn advance(bodies: &mut [Body; N_BODIES], dt: f64) {
-    const N: usize = N_BODIES * (N_BODIES - 1) / 2;
+    fn advance(bodies: &mut [Body; N_BODIES], dt: f64) {
+        const N: usize = N_BODIES * (N_BODIES - 1) / 2;
+
+        // compute distance between bodies:
+        let mut r = [f64x4::splat(0.); N];
+        {
+            let mut i = 0;
+            for j in 0..N_BODIES {
+                for k in j + 1..N_BODIES {
+                    r[i] = bodies[j].x - bodies[k].x;
+                    i += 1;
+                }
+            }
+        }
+
+        let mut mag = [0.0; N];
+        for i in (0..N).step_by(2) {
+            let d2s = f64x2::from_array([
+                (r[i] * r[i]).horizontal_sum(),
+                (r[i + 1] * r[i + 1]).horizontal_sum(),
+            ]);
+            let dmags = f64x2::splat(dt) / (d2s * d2s.sqrt());
+            mag[i] = dmags[0];
+            mag[i + 1] = dmags[1];
+        }
 
-    // compute distance between bodies:
-    let mut r = [f64x4::splat(0.); N];
-    {
         let mut i = 0;
         for j in 0..N_BODIES {
             for k in j + 1..N_BODIES {
-                r[i] = bodies[j].x - bodies[k].x;
-                i += 1;
+                let f = r[i] * mag[i];
+                bodies[j].v -= f * bodies[k].mass;
+                bodies[k].v += f * bodies[j].mass;
+                i += 1
             }
         }
+        for body in bodies {
+            body.x += dt * body.v
+        }
     }
 
-    let mut mag = [0.0; N];
-    for i in (0..N).step_by(2) {
-        let d2s = f64x2::from_array([
-            (r[i] * r[i]).horizontal_sum(),
-            (r[i + 1] * r[i + 1]).horizontal_sum(),
-        ]);
-        let dmags = f64x2::splat(dt) / (d2s * d2s.sqrt());
-        mag[i] = dmags[0];
-        mag[i + 1] = dmags[1];
-    }
-
-    let mut i = 0;
-    for j in 0..N_BODIES {
-        for k in j + 1..N_BODIES {
-            let f = r[i] * mag[i];
-            bodies[j].v -= f * bodies[k].mass;
-            bodies[k].v += f * bodies[j].mass;
-            i += 1
+    pub fn run(n: usize) -> (f64, f64) {
+        let mut bodies = BODIES;
+        offset_momentum(&mut bodies);
+        let energy_before = energy(&bodies);
+        for _ in 0..n {
+            advance(&mut bodies, 0.01);
         }
-    }
-    for body in bodies {
-        body.x += dt * body.v
-    }
-}
+        let energy_after = energy(&bodies);
 
-pub fn run(n: usize) -> (f64, f64) {
-    let mut bodies = BODIES;
-    offset_momentum(&mut bodies);
-    let energy_before = energy(&bodies);
-    for _ in 0..n {
-        advance(&mut bodies, 0.01);
+        (energy_before, energy_after)
     }
-    let energy_after = energy(&bodies);
-
-    (energy_before, energy_after)
 }
 
+#[cfg(feature = "std")]
 #[cfg(test)]
 mod tests {
     // Good enough for demonstration purposes, not going for strictness here.
@@ -173,12 +177,17 @@ mod tests {
     #[test]
     fn test() {
         const OUTPUT: [f64; 2] = [-0.169075164, -0.169087605];
-        let (energy_before, energy_after) = super::run(1000);
+        let (energy_before, energy_after) = super::nbody::run(1000);
         assert!(approx_eq_f64(energy_before, OUTPUT[0]));
         assert!(approx_eq_f64(energy_after, OUTPUT[1]));
     }
 }
 
 fn main() {
-    // empty main to pass CI
+    #[cfg(feature = "std")]
+    {
+        let (energy_before, energy_after) = nbody::run(1000);
+        println!("Energy before: {}", energy_before);
+        println!("Energy after:  {}", energy_after);
+    }
 }

crates/core_simd/src/intrinsics.rs

@@ -47,6 +47,7 @@ extern "platform-intrinsic" {
     pub(crate) fn simd_fabs<T>(x: T) -> T;
 
     /// fsqrt
+    #[cfg(feature = "std")]
     pub(crate) fn simd_fsqrt<T>(x: T) -> T;
 
     /// fma

crates/core_simd/src/lane_count.rs

@@ -6,9 +6,14 @@ use sealed::Sealed;
 /// A type representing a vector lane count.
 pub struct LaneCount<const LANES: usize>;
 
+impl<const LANES: usize> LaneCount<LANES> {
+    /// The number of bytes in a bitmask with this many lanes.
+    pub const BITMASK_LEN: usize = (LANES + 7) / 8;
+}
+
 /// Helper trait for vector lane counts.
 pub trait SupportedLaneCount: Sealed {
-    /// The bitmask representation of a mask.
+    #[doc(hidden)]
     type BitMask: Copy + Default + AsRef<[u8]> + AsMut<[u8]>;
 
     #[doc(hidden)]