From 8e550119cbd37019cc44df0af503dc5fd48f15f2 Mon Sep 17 00:00:00 2001
From: "Jorge C. Leitao" <jorgecarleitao@gmail.com>
Date: Mon, 10 Jan 2022 06:23:05 +0000
Subject: [PATCH 1/5] Improved bench

---
 benches/aggregate.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/benches/aggregate.rs b/benches/aggregate.rs
index a8b666458fe..d515fff1281 100644
--- a/benches/aggregate.rs
+++ b/benches/aggregate.rs
@@ -4,12 +4,12 @@ use arrow2::array::*;
 use arrow2::compute::aggregate::*;
 use arrow2::util::bench_util::*;
 
-fn bench_sum(arr_a: &PrimitiveArray<f32>) {
+fn bench_sum(arr_a: &dyn Array) {
     sum(criterion::black_box(arr_a)).unwrap();
 }
 
-fn bench_min(arr_a: &PrimitiveArray<f32>) {
-    min_primitive(criterion::black_box(arr_a)).unwrap();
+fn bench_min(arr_a: &dyn Array) {
+    min(criterion::black_box(arr_a)).unwrap();
 }
 
 fn add_benchmark(c: &mut Criterion) {
@@ -24,6 +24,15 @@ fn add_benchmark(c: &mut Criterion) {
             b.iter(|| bench_min(&arr_a))
         });
 
+        let arr_a = create_primitive_array::<i32>(size, 0.0);
+
+        c.bench_function(&format!("sum 2^{} i32", log2_size), |b| {
+            b.iter(|| bench_sum(&arr_a))
+        });
+        c.bench_function(&format!("min 2^{} i32", log2_size), |b| {
+            b.iter(|| bench_min(&arr_a))
+        });
+
         let arr_a = create_primitive_array::<f32>(size, 0.1);
 
         c.bench_function(&format!("sum null 2^{} f32", log2_size), |b| {

From 767b9febcb6b00aa633fa709f4976c2d107ce843 Mon Sep 17 00:00:00 2001
From: "Jorge C. Leitao" <jorgecarleitao@gmail.com>
Date: Mon, 22 Nov 2021 05:20:55 +0000
Subject: [PATCH 2/5] Migrated to portable simd

---
 Cargo.toml                            |  4 +--
 src/compute/aggregate/min_max.rs      | 20 +++++++-------
 src/compute/aggregate/simd/native.rs  |  8 +++---
 src/compute/aggregate/simd/packed.rs  | 36 ++++++++++++-------------
 src/compute/comparison/simd/packed.rs | 29 +++++++++++++-------
 src/lib.rs                            |  1 +
 src/types/simd/mod.rs                 |  2 +-
 src/types/simd/packed.rs              | 38 +++++++++++++++------------
 tests/it/compute/aggregate/min_max.rs | 16 +++++++++++
 9 files changed, 92 insertions(+), 62 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index d5d9a832d66..346fcc45a95 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -61,8 +61,6 @@ itertools = { version = "^0.10", optional = true }
 
 base64 = { version = "0.13.0", optional = true }
 
-packed_simd = { version = "0.3", optional = true, package = "packed_simd_2" }
-
 # to write to parquet as a stream
 futures = { version = "0.3", optional = true }
 
@@ -211,8 +209,8 @@ compute = [
     "compute_window"
 ]
 benchmarks = ["rand"]
-simd = ["packed_simd"]
 serde_types = ["serde", "serde_derive"]
+simd = []
 
 [package.metadata.cargo-all-features]
 allowlist = ["compute", "compute_sort", "compute_hash", "compute_nullif"]
diff --git a/src/compute/aggregate/min_max.rs b/src/compute/aggregate/min_max.rs
index 32453cd7247..fe89bf41537 100644
--- a/src/compute/aggregate/min_max.rs
+++ b/src/compute/aggregate/min_max.rs
@@ -21,9 +21,9 @@ pub trait SimdOrd<T> {
     /// reduce itself to the maximum
     fn min_element(self) -> T;
     /// lane-wise maximum between two instances
-    fn max(self, x: Self) -> Self;
+    fn max_lane(self, x: Self) -> Self;
     /// lane-wise minimum between two instances
-    fn min(self, x: Self) -> Self;
+    fn min_lane(self, x: Self) -> Self;
     /// returns a new instance with all lanes equal to `MIN`
     fn new_min() -> Self;
     /// returns a new instance with all lanes equal to `MAX`
@@ -120,11 +120,11 @@ where
 
     let chunk_reduced = chunks.fold(T::Simd::new_min(), |acc, chunk| {
         let chunk = T::Simd::from_chunk(chunk);
-        acc.min(chunk)
+        acc.min_lane(chunk)
     });
 
     let remainder = T::Simd::from_incomplete_chunk(remainder, T::Simd::MAX);
-    let reduced = chunk_reduced.min(remainder);
+    let reduced = chunk_reduced.min_lane(remainder);
 
     reduced.min_element()
 }
@@ -143,14 +143,14 @@ where
             let chunk = T::Simd::from_chunk(chunk);
             let mask = <T::Simd as NativeSimd>::Mask::from_chunk(validity_chunk);
             let chunk = chunk.select(mask, T::Simd::new_min());
-            acc.min(chunk)
+            acc.min_lane(chunk)
         },
     );
 
     let remainder = T::Simd::from_incomplete_chunk(chunks.remainder(), T::Simd::MAX);
     let mask = <T::Simd as NativeSimd>::Mask::from_chunk(validity_masks.remainder());
     let remainder = remainder.select(mask, T::Simd::new_min());
-    let reduced = chunk_reduced.min(remainder);
+    let reduced = chunk_reduced.min_lane(remainder);
 
     reduced.min_element()
 }
@@ -199,11 +199,11 @@ where
 
     let chunk_reduced = chunks.fold(T::Simd::new_max(), |acc, chunk| {
         let chunk = T::Simd::from_chunk(chunk);
-        acc.max(chunk)
+        acc.max_lane(chunk)
     });
 
     let remainder = T::Simd::from_incomplete_chunk(remainder, T::Simd::MIN);
-    let reduced = chunk_reduced.max(remainder);
+    let reduced = chunk_reduced.max_lane(remainder);
 
     reduced.max_element()
 }
@@ -222,14 +222,14 @@ where
             let chunk = T::Simd::from_chunk(chunk);
             let mask = <T::Simd as NativeSimd>::Mask::from_chunk(validity_chunk);
             let chunk = chunk.select(mask, T::Simd::new_max());
-            acc.max(chunk)
+            acc.max_lane(chunk)
         },
     );
 
     let remainder = T::Simd::from_incomplete_chunk(chunks.remainder(), T::Simd::MIN);
     let mask = <T::Simd as NativeSimd>::Mask::from_chunk(validity_masks.remainder());
     let remainder = remainder.select(mask, T::Simd::new_max());
-    let reduced = chunk_reduced.max(remainder);
+    let reduced = chunk_reduced.max_lane(remainder);
 
     reduced.max_element()
 }
diff --git a/src/compute/aggregate/simd/native.rs b/src/compute/aggregate/simd/native.rs
index 9c573ca9e76..3304d5ea2b0 100644
--- a/src/compute/aggregate/simd/native.rs
+++ b/src/compute/aggregate/simd/native.rs
@@ -70,7 +70,7 @@ macro_rules! simd_ord_int {
             }
 
             #[inline]
-            fn max(self, x: Self) -> Self {
+            fn max_lane(self, x: Self) -> Self {
                 let mut result = <$simd>::default();
                 result
                     .0
@@ -82,7 +82,7 @@ macro_rules! simd_ord_int {
             }
 
             #[inline]
-            fn min(self, x: Self) -> Self {
+            fn min_lane(self, x: Self) -> Self {
                 let mut result = <$simd>::default();
                 result
                     .0
@@ -123,7 +123,7 @@ macro_rules! simd_ord_float {
             }
 
             #[inline]
-            fn max(self, x: Self) -> Self {
+            fn max_lane(self, x: Self) -> Self {
                 let mut result = <$simd>::default();
                 result
                     .0
@@ -135,7 +135,7 @@ macro_rules! simd_ord_float {
             }
 
             #[inline]
-            fn min(self, x: Self) -> Self {
+            fn min_lane(self, x: Self) -> Self {
                 let mut result = <$simd>::default();
                 result
                     .0
diff --git a/src/compute/aggregate/simd/packed.rs b/src/compute/aggregate/simd/packed.rs
index 5ce69468f4e..7af9ac2a4e2 100644
--- a/src/compute/aggregate/simd/packed.rs
+++ b/src/compute/aggregate/simd/packed.rs
@@ -14,16 +14,16 @@ macro_rules! simd_sum {
     };
 }
 
-simd_sum!(f32x16, f32, sum);
-simd_sum!(f64x8, f64, sum);
-simd_sum!(u8x64, u8, wrapping_sum);
-simd_sum!(u16x32, u16, wrapping_sum);
-simd_sum!(u32x16, u32, wrapping_sum);
-simd_sum!(u64x8, u64, wrapping_sum);
-simd_sum!(i8x64, i8, wrapping_sum);
-simd_sum!(i16x32, i16, wrapping_sum);
-simd_sum!(i32x16, i32, wrapping_sum);
-simd_sum!(i64x8, i64, wrapping_sum);
+simd_sum!(f32x16, f32, horizontal_sum);
+simd_sum!(f64x8, f64, horizontal_sum);
+simd_sum!(u8x64, u8, horizontal_sum);
+simd_sum!(u16x32, u16, horizontal_sum);
+simd_sum!(u32x16, u32, horizontal_sum);
+simd_sum!(u64x8, u64, horizontal_sum);
+simd_sum!(i8x64, i8, horizontal_sum);
+simd_sum!(i16x32, i16, horizontal_sum);
+simd_sum!(i32x16, i32, horizontal_sum);
+simd_sum!(i64x8, i64, horizontal_sum);
 
 macro_rules! simd_ord_int {
     ($simd:tt, $type:ty) => {
@@ -33,21 +33,21 @@ macro_rules! simd_ord_int {
 
             #[inline]
             fn max_element(self) -> $type {
-                self.max_element()
+                self.horizontal_max()
             }
 
             #[inline]
             fn min_element(self) -> $type {
-                self.min_element()
+                self.horizontal_min()
             }
 
             #[inline]
-            fn max(self, x: Self) -> Self {
+            fn max_lane(self, x: Self) -> Self {
                 self.max(x)
             }
 
             #[inline]
-            fn min(self, x: Self) -> Self {
+            fn min_lane(self, x: Self) -> Self {
                 self.min(x)
             }
 
@@ -72,21 +72,21 @@ macro_rules! simd_ord_float {
 
             #[inline]
             fn max_element(self) -> $type {
-                self.max_element()
+                self.horizontal_max()
             }
 
             #[inline]
             fn min_element(self) -> $type {
-                self.min_element()
+                self.horizontal_min()
             }
 
             #[inline]
-            fn max(self, x: Self) -> Self {
+            fn max_lane(self, x: Self) -> Self {
                 self.max(x)
             }
 
             #[inline]
-            fn min(self, x: Self) -> Self {
+            fn min_lane(self, x: Self) -> Self {
                 self.min(x)
             }
 
diff --git a/src/compute/comparison/simd/packed.rs b/src/compute/comparison/simd/packed.rs
index 1c18df437cc..c36c6d52cd7 100644
--- a/src/compute/comparison/simd/packed.rs
+++ b/src/compute/comparison/simd/packed.rs
@@ -1,6 +1,6 @@
 use std::convert::TryInto;
 
-use packed_simd::*;
+use crate::types::simd::*;
 
 use crate::types::{days_ms, months_days_ns};
 
@@ -15,48 +15,48 @@ macro_rules! simd8 {
         impl Simd8Lanes<$type> for $md {
             #[inline]
             fn from_chunk(v: &[$type]) -> Self {
-                <$md>::from_slice_unaligned(v)
+                <$md>::from_slice(v)
             }
 
             #[inline]
             fn from_incomplete_chunk(v: &[$type], remaining: $type) -> Self {
                 let mut a = [remaining; 8];
                 a.iter_mut().zip(v.iter()).for_each(|(a, b)| *a = *b);
-                Self::from_chunk(a.as_ref())
+                Self::from_array(a)
             }
         }
 
         impl Simd8PartialEq for $md {
             #[inline]
             fn eq(self, other: Self) -> u8 {
-                self.eq(other).bitmask()
+                to_bitmask(self.lanes_eq(other))
             }
 
             #[inline]
             fn neq(self, other: Self) -> u8 {
-                self.ne(other).bitmask()
+                to_bitmask(self.lanes_ne(other))
             }
         }
 
         impl Simd8PartialOrd for $md {
             #[inline]
             fn lt_eq(self, other: Self) -> u8 {
-                self.le(other).bitmask()
+                to_bitmask(self.lanes_le(other))
             }
 
             #[inline]
             fn lt(self, other: Self) -> u8 {
-                self.lt(other).bitmask()
+                to_bitmask(self.lanes_lt(other))
             }
 
             #[inline]
             fn gt_eq(self, other: Self) -> u8 {
-                self.ge(other).bitmask()
+                to_bitmask(self.lanes_ge(other))
             }
 
             #[inline]
             fn gt(self, other: Self) -> u8 {
-                self.gt(other).bitmask()
+                to_bitmask(self.lanes_gt(other))
             }
         }
     };
@@ -77,3 +77,14 @@ simd8_native!(days_ms);
 simd8_native_partial_eq!(days_ms);
 simd8_native!(months_days_ns);
 simd8_native_partial_eq!(months_days_ns);
+
+fn to_bitmask<T: std::simd::MaskElement>(mask: std::simd::Mask<T, 8>) -> u8 {
+    mask.test(0) as u8
+        | ((mask.test(1) as u8) << 1)
+        | ((mask.test(2) as u8) << 2)
+        | ((mask.test(3) as u8) << 3)
+        | ((mask.test(4) as u8) << 4)
+        | ((mask.test(5) as u8) << 5)
+        | ((mask.test(6) as u8) << 6)
+        | ((mask.test(7) as u8) << 7)
+}
diff --git a/src/lib.rs b/src/lib.rs
index f96f933c39a..7abafb78288 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,7 @@
 //
 #![allow(clippy::len_without_is_empty)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(feature = "simd", feature(portable_simd))]
 
 #[macro_use]
 pub mod array;
diff --git a/src/types/simd/mod.rs b/src/types/simd/mod.rs
index 0859a1027b3..9db728b565e 100644
--- a/src/types/simd/mod.rs
+++ b/src/types/simd/mod.rs
@@ -14,7 +14,7 @@ pub trait FromMaskChunk<T> {
 /// # Safety
 /// The `NativeType` and the `NativeSimd` must have possible a matching alignment.
 /// e.g. slicing `&[NativeType]` by `align_of<NativeSimd>()` must be properly aligned/safe.
-pub unsafe trait NativeSimd: Default + Copy {
+pub unsafe trait NativeSimd: Sized + Default + Copy {
     /// Number of lanes
     const LANES: usize;
     /// The [`NativeType`] of this struct. E.g. `f32` for a `NativeSimd = f32x16`.
diff --git a/src/types/simd/packed.rs b/src/types/simd/packed.rs
index 160d47ecc35..0c03327212a 100644
--- a/src/types/simd/packed.rs
+++ b/src/types/simd/packed.rs
@@ -1,8 +1,12 @@
-pub use packed_simd::{
-    f32x16, f64x8, i16x32, i32x16, i64x8, i8x64, m16x32, m32x16, m64x8, m8x64, u16x32, u32x16,
-    u64x8, u8x64,
+pub use std::simd::{
+    f32x16, f32x8, f64x8, i16x32, i16x8, i32x16, i32x8, i64x8, i8x64, i8x8, mask32x16 as m32x16,
+    mask64x8 as m64x8, mask8x64 as m8x64, u16x32, u16x8, u32x16, u32x8, u64x8, u8x64, u8x8,
 };
 
+/// Vector of 32 16-bit masks
+#[allow(non_camel_case_types)]
+pub type m16x32 = std::simd::Mask<i16, 32>;
+
 use super::*;
 
 macro_rules! simd {
@@ -20,7 +24,7 @@ macro_rules! simd {
 
             #[inline]
             fn from_chunk(v: &[$type]) -> Self {
-                <$name>::from_slice_unaligned(v)
+                <$name>::from_slice(v)
             }
 
             #[inline]
@@ -67,28 +71,28 @@ chunk_macro!(u64, u8, u64x8, m64x8, from_chunk_u8);
 
 #[inline]
 fn from_chunk_u8(chunk: u8) -> m64x8 {
-    let idx = u64x8::new(1, 2, 4, 8, 16, 32, 64, 128);
+    let idx = u64x8::from_array([1, 2, 4, 8, 16, 32, 64, 128]);
     let vecmask = u64x8::splat(chunk as u64);
 
-    (idx & vecmask).eq(idx)
+    (idx & vecmask).lanes_eq(idx)
 }
 
 #[inline]
 fn from_chunk_u16(chunk: u16) -> m32x16 {
-    let idx = u32x16::new(
+    let idx = u32x16::from_array([
         1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
-    );
+    ]);
     let vecmask = u32x16::splat(chunk as u32);
 
-    (idx & vecmask).eq(idx)
+    (idx & vecmask).lanes_eq(idx)
 }
 
 #[inline]
 fn from_chunk_u32(chunk: u32) -> m16x32 {
-    let idx = u16x32::new(
+    let idx = u16x32::from_array([
         1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 1, 2, 4, 8,
         16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
-    );
+    ]);
     let left = u16x32::from_chunk(&[
         1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -105,16 +109,16 @@ fn from_chunk_u32(chunk: u32) -> m16x32 {
     let vecmask1 = u16x32::splat(a1);
     let vecmask2 = u16x32::splat(a2);
 
-    (idx & left & vecmask1).eq(idx) | (idx & right & vecmask2).eq(idx)
+    (idx & left & vecmask1).lanes_eq(idx) | (idx & right & vecmask2).lanes_eq(idx)
 }
 
 #[inline]
 fn from_chunk_u64(chunk: u64) -> m8x64 {
-    let idx = u8x64::new(
+    let idx = u8x64::from_array([
         1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128, 1,
         2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128, 1, 2,
         4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128,
-    );
+    ]);
     let idxs = [
         u8x64::from_chunk(&[
             1, 2, 4, 8, 16, 32, 64, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -162,7 +166,7 @@ fn from_chunk_u64(chunk: u64) -> m8x64 {
 
     let mut result = m8x64::default();
     for i in 0..8 {
-        result |= (idxs[i] & u8x64::splat(a[i])).eq(idx)
+        result |= (idxs[i] & u8x64::splat(a[i])).lanes_eq(idx)
     }
 
     result
@@ -177,7 +181,7 @@ mod tests {
         let a = 0b00000001000000010000000100000001u32;
         let a = from_chunk_u32(a);
         for i in 0..32 {
-            assert_eq!(a.extract(i), i % 8 == 0)
+            assert_eq!(a.test(i), i % 8 == 0)
         }
     }
 
@@ -186,7 +190,7 @@ mod tests {
         let a = 0b0000000100000001000000010000000100000001000000010000000100000001u64;
         let a = from_chunk_u64(a);
         for i in 0..64 {
-            assert_eq!(a.extract(i), i % 8 == 0)
+            assert_eq!(a.test(i), i % 8 == 0)
         }
     }
 }
diff --git a/tests/it/compute/aggregate/min_max.rs b/tests/it/compute/aggregate/min_max.rs
index abeaf304596..bd0ac99e3a5 100644
--- a/tests/it/compute/aggregate/min_max.rs
+++ b/tests/it/compute/aggregate/min_max.rs
@@ -51,6 +51,22 @@ fn min_max_f64_large() {
         None,
         Some(5.0),
         Some(2.0),
+        None,
+        None,
+        Some(8.0),
+        Some(2.0),
+        None,
+        None,
+        Some(5.0),
+        Some(2.0),
+        None,
+        None,
+        Some(8.0),
+        Some(2.0),
+        None,
+        None,
+        Some(5.0),
+        Some(2.0),
     ]);
     assert_eq!(Some(2.0), min_primitive(&a));
     assert_eq!(Some(8.0), max_primitive(&a));

From 1df6e1c97e52cea50edaa6bf197d102e0f56fefd Mon Sep 17 00:00:00 2001
From: "Jorge C. Leitao" <jorgecarleitao@gmail.com>
Date: Sat, 5 Mar 2022 15:30:42 +0000
Subject: [PATCH 3/5] Used intrinsic for to_bitmask

---
 src/compute/comparison/simd/packed.rs | 25 +++++++------------------
 1 file changed, 7 insertions(+), 18 deletions(-)

diff --git a/src/compute/comparison/simd/packed.rs b/src/compute/comparison/simd/packed.rs
index c36c6d52cd7..9348cbed484 100644
--- a/src/compute/comparison/simd/packed.rs
+++ b/src/compute/comparison/simd/packed.rs
@@ -1,7 +1,7 @@
 use std::convert::TryInto;
+use std::simd::ToBitMask;
 
 use crate::types::simd::*;
-
 use crate::types::{days_ms, months_days_ns};
 
 use super::*;
@@ -29,34 +29,34 @@ macro_rules! simd8 {
         impl Simd8PartialEq for $md {
             #[inline]
             fn eq(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_eq(other))
+                self.lanes_eq(other).to_bitmask()
             }
 
             #[inline]
             fn neq(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_ne(other))
+                self.lanes_ne(other).to_bitmask()
             }
         }
 
         impl Simd8PartialOrd for $md {
             #[inline]
             fn lt_eq(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_le(other))
+                self.lanes_le(other).to_bitmask()
             }
 
             #[inline]
             fn lt(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_lt(other))
+                self.lanes_lt(other).to_bitmask()
             }
 
             #[inline]
             fn gt_eq(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_ge(other))
+                self.lanes_ge(other).to_bitmask()
             }
 
             #[inline]
             fn gt(self, other: Self) -> u8 {
-                to_bitmask(self.lanes_gt(other))
+                self.lanes_gt(other).to_bitmask()
             }
         }
     };
@@ -77,14 +77,3 @@ simd8_native!(days_ms);
 simd8_native_partial_eq!(days_ms);
 simd8_native!(months_days_ns);
 simd8_native_partial_eq!(months_days_ns);
-
-fn to_bitmask<T: std::simd::MaskElement>(mask: std::simd::Mask<T, 8>) -> u8 {
-    mask.test(0) as u8
-        | ((mask.test(1) as u8) << 1)
-        | ((mask.test(2) as u8) << 2)
-        | ((mask.test(3) as u8) << 3)
-        | ((mask.test(4) as u8) << 4)
-        | ((mask.test(5) as u8) << 5)
-        | ((mask.test(6) as u8) << 6)
-        | ((mask.test(7) as u8) << 7)
-}

From de4f3da5b1815e91600a7857104ee7d053aa4d2a Mon Sep 17 00:00:00 2001
From: "Jorge C. Leitao" <jorgecarleitao@gmail.com>
Date: Sat, 5 Mar 2022 16:25:35 +0000
Subject: [PATCH 4/5] Bumped nightly

---
 .github/workflows/test.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d921bb53573..86e18a52c07 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -76,7 +76,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2021-12-10
+          toolchain: nightly-2022-03-02
           override: true
       - uses: Swatinem/rust-cache@v1
         with:
@@ -99,7 +99,7 @@ jobs:
           submodules: true # needed to test IPC, which are located in a submodule
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2021-12-10
+          toolchain: nightly-2022-03-02
           override: true
       - uses: Swatinem/rust-cache@v1
         with:
@@ -189,7 +189,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-01-17
+          toolchain: nightly-2022-03-02
           override: true
       - uses: Swatinem/rust-cache@v1
       - name: Run

From db5cdce88fb38b83facf39d0e69a4b6b24109ff9 Mon Sep 17 00:00:00 2001
From: "Jorge C. Leitao" <jorgecarleitao@gmail.com>
Date: Sat, 5 Mar 2022 17:46:52 +0000
Subject: [PATCH 5/5] Bumped nightly to miri

---
 .github/workflows/test.yml | 6 +++---
 src/doc/lib.md             | 2 +-
 src/types/simd/mod.rs      | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 86e18a52c07..519579b83d8 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -76,7 +76,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-03-02
+          toolchain: nightly-2022-03-03
           override: true
       - uses: Swatinem/rust-cache@v1
         with:
@@ -99,7 +99,7 @@ jobs:
           submodules: true # needed to test IPC, which are located in a submodule
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-03-02
+          toolchain: nightly-2022-03-03
           override: true
       - uses: Swatinem/rust-cache@v1
         with:
@@ -189,7 +189,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-03-02
+          toolchain: nightly-2022-03-03
           override: true
       - uses: Swatinem/rust-cache@v1
       - name: Run
diff --git a/src/doc/lib.md b/src/doc/lib.md
index 3fb07c1e42f..9638ff47480 100644
--- a/src/doc/lib.md
+++ b/src/doc/lib.md
@@ -87,5 +87,5 @@ functionality, such as:
 * `compute` to operate on arrays (addition, sum, sort, etc.)
 
 The feature `simd` (not part of `full`) produces more explicit SIMD instructions
-via [`packed_simd`](https://github.com/rust-lang/packed_simd), but requires the 
+via [`std::simd`](https://doc.rust-lang.org/nightly/std/simd/index.html), but requires the 
 nightly channel.
diff --git a/src/types/simd/mod.rs b/src/types/simd/mod.rs
index 9db728b565e..d12e61bcd50 100644
--- a/src/types/simd/mod.rs
+++ b/src/types/simd/mod.rs
@@ -1,6 +1,6 @@
 //! Contains traits and implementations of multi-data used in SIMD.
 //! The actual representation is driven by the feature flag `"simd"`, which, if set,
-//! uses `packed_simd2` to get the intrinsics.
+//! uses [`std::simd`].
 use super::{days_ms, months_days_ns};
 use super::{BitChunk, BitChunkIter, NativeType};