From b1ae000f6da1abd3b8e9b80c40bc11c89b8ae93c Mon Sep 17 00:00:00 2001 From: bjorn3 Date: Thu, 30 Dec 2021 16:54:40 +0100 Subject: [PATCH] [core] Disable portable-simd test --- library/core/tests/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index aa1ad93..95fbf55 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -398,23 +398,4 @@ pub mod arch { } } -// Pull in the `core_simd` crate directly into libcore. The contents of -// `core_simd` are in a different repository: rust-lang/portable-simd. -// -// `core_simd` depends on libcore, but the contents of this module are -// set up in such a way that directly pulling it here works such that the -// crate uses this crate as its libcore. -#[path = "../../portable-simd/crates/core_simd/src/mod.rs"] -#[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn, unused_unsafe)] -#[allow(rustdoc::bare_urls)] -#[unstable(feature = "portable_simd", issue = "86656")] -mod core_simd; - -#[doc = include_str!("../../portable-simd/crates/core_simd/src/core_simd_docs.md")] -#[unstable(feature = "portable_simd", issue = "86656")] -pub mod simd { - #[unstable(feature = "portable_simd", issue = "86656")] - pub use crate::core_simd::simd::*; -} - include!("primitive_docs.rs"); diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index cd38c3a..ad632dc 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -17,6 +17,5 @@ use crate::ptr; use crate::result::Result; use crate::result::Result::{Err, Ok}; -use crate::simd::{self, Simd}; use crate::slice; #[unstable( @@ -3475,121 +3474,6 @@ impl [T] { } } - /// Split a slice into a prefix, a middle of aligned SIMD types, and a suffix. - /// - /// This is a safe wrapper around [`slice::align_to`], so has the same weak - /// postconditions as that method. You're only assured that - /// `self.len() == prefix.len() + middle.len() * LANES + suffix.len()`. - /// - /// Notably, all of the following are possible: - /// - `prefix.len() >= LANES`. - /// - `middle.is_empty()` despite `self.len() >= 3 * LANES`. - /// - `suffix.len() >= LANES`. - /// - /// That said, this is a safe method, so if you're only writing safe code, - /// then this can at most cause incorrect logic, not unsoundness. - /// - /// # Panics - /// - /// This will panic if the size of the SIMD type is different from - /// `LANES` times that of the scalar. - /// - /// At the time of writing, the trait restrictions on `Simd` keeps - /// that from ever happening, as only power-of-two numbers of lanes are - /// supported. It's possible that, in the future, those restrictions might - /// be lifted in a way that would make it possible to see panics from this - /// method for something like `LANES == 3`. - /// - /// # Examples - /// - /// ``` - /// #![feature(portable_simd)] - /// - /// let short = &[1, 2, 3]; - /// let (prefix, middle, suffix) = short.as_simd::<4>(); - /// assert_eq!(middle, []); // Not enough elements for anything in the middle - /// - /// // They might be split in any possible way between prefix and suffix - /// let it = prefix.iter().chain(suffix).copied(); - /// assert_eq!(it.collect::>(), vec![1, 2, 3]); - /// - /// fn basic_simd_sum(x: &[f32]) -> f32 { - /// use std::ops::Add; - /// use std::simd::f32x4; - /// let (prefix, middle, suffix) = x.as_simd(); - /// let sums = f32x4::from_array([ - /// prefix.iter().copied().sum(), - /// 0.0, - /// 0.0, - /// suffix.iter().copied().sum(), - /// ]); - /// let sums = middle.iter().copied().fold(sums, f32x4::add); - /// sums.reduce_sum() - /// } - /// - /// let numbers: Vec = (1..101).map(|x| x as _).collect(); - /// assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0); - /// ``` - #[unstable(feature = "portable_simd", issue = "86656")] - pub fn as_simd(&self) -> (&[T], &[Simd], &[T]) - where - Simd: AsRef<[T; LANES]>, - T: simd::SimdElement, - simd::LaneCount: simd::SupportedLaneCount, - { - // These are expected to always match, as vector types are laid out like - // arrays per , but we - // might as well double-check since it'll optimize away anyhow. - assert_eq!(mem::size_of::>(), mem::size_of::<[T; LANES]>()); - - // SAFETY: The simd types have the same layout as arrays, just with - // potentially-higher alignment, so the de-facto transmutes are sound. - unsafe { self.align_to() } - } - - /// Split a slice into a prefix, a middle of aligned SIMD types, and a suffix. - /// - /// This is a safe wrapper around [`slice::align_to_mut`], so has the same weak - /// postconditions as that method. You're only assured that - /// `self.len() == prefix.len() + middle.len() * LANES + suffix.len()`. - /// - /// Notably, all of the following are possible: - /// - `prefix.len() >= LANES`. - /// - `middle.is_empty()` despite `self.len() >= 3 * LANES`. - /// - `suffix.len() >= LANES`. - /// - /// That said, this is a safe method, so if you're only writing safe code, - /// then this can at most cause incorrect logic, not unsoundness. - /// - /// This is the mutable version of [`slice::as_simd`]; see that for examples. - /// - /// # Panics - /// - /// This will panic if the size of the SIMD type is different from - /// `LANES` times that of the scalar. - /// - /// At the time of writing, the trait restrictions on `Simd` keeps - /// that from ever happening, as only power-of-two numbers of lanes are - /// supported. It's possible that, in the future, those restrictions might - /// be lifted in a way that would make it possible to see panics from this - /// method for something like `LANES == 3`. - #[unstable(feature = "portable_simd", issue = "86656")] - pub fn as_simd_mut(&mut self) -> (&mut [T], &mut [Simd], &mut [T]) - where - Simd: AsMut<[T; LANES]>, - T: simd::SimdElement, - simd::LaneCount: simd::SupportedLaneCount, - { - // These are expected to always match, as vector types are laid out like - // arrays per , but we - // might as well double-check since it'll optimize away anyhow. - assert_eq!(mem::size_of::>(), mem::size_of::<[T; LANES]>()); - - // SAFETY: The simd types have the same layout as arrays, just with - // potentially-higher alignment, so the de-facto transmutes are sound. - unsafe { self.align_to_mut() } - } - /// Checks if the elements of this slice are sorted. /// /// That is, for each element `a` and its following element `b`, `a <= b` must hold. If the diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index 06c7be0..359e2e7 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -75,7 +75,6 @@ #![feature(never_type)] #![feature(unwrap_infallible)] #![feature(result_into_ok_or_err)] -#![feature(portable_simd)] #![feature(ptr_metadata)] #![feature(once_cell)] #![feature(option_result_contains)] @@ -127,7 +126,6 @@ mod pin; mod pin_macro; mod ptr; mod result; -mod simd; mod slice; mod str; mod str_lossy; diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 5dc586d..b6fc48f 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -312,6 +312,5 @@ #![feature(panic_can_unwind)] #![feature(panic_unwind)] #![feature(platform_intrinsics)] -#![feature(portable_simd)] #![feature(prelude_import)] #![feature(ptr_as_uninit)] @@ -508,23 +508,6 @@ pub mod time; #[unstable(feature = "once_cell", issue = "74465")] pub mod lazy; -// Pull in `std_float` crate into libstd. The contents of -// `std_float` are in a different repository: rust-lang/portable-simd. -#[path = "../../portable-simd/crates/std_float/src/lib.rs"] -#[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn, unused_unsafe)] -#[allow(rustdoc::bare_urls)] -#[unstable(feature = "portable_simd", issue = "86656")] -mod std_float; - -#[doc = include_str!("../../portable-simd/crates/core_simd/src/core_simd_docs.md")] -#[unstable(feature = "portable_simd", issue = "86656")] -pub mod simd { - #[doc(inline)] - pub use crate::std_float::StdFloat; - #[doc(inline)] - pub use core::simd::*; -} - #[stable(feature = "futures_api", since = "1.36.0")] pub mod task { //! Types and Traits for working with asynchronous tasks. -- 2.26.2.7.g19db9cfb68