Select tiny sorts for 16-bit platforms

Voultapher · Voultapher · commit 670630da1812 · 2024-09-04T19:53:56.000+02:00
Also skips stack alloc in stable sort if 16-bit target platform.
diff --git a/core/src/slice/sort/stable/mod.rs b/core/src/slice/sort/stable/mod.rs
@@ -40,20 +40,27 @@ pub fn sort<T, F: FnMut(&T, &T) -> bool, BufT: BufGuard<T>>(v: &mut [T], is_less
     }
 
     cfg_if! {
-        if #[cfg(feature = "optimize_for_size")] {
+        if #[cfg(any(feature = "optimize_for_size", target_pointer_width = "16"))] {
             let alloc_len = len / 2;
 
-            // For small inputs 4KiB of stack storage suffices, which allows us to avoid
-            // calling the (de-)allocator. Benchmarks showed this was quite beneficial.
-            let mut stack_buf = AlignedStorage::<T, 4096>::new();
-            let stack_scratch = stack_buf.as_uninit_slice_mut();
-            let mut heap_buf;
-            let scratch = if stack_scratch.len() >= alloc_len {
-                stack_scratch
-            } else {
-                heap_buf = BufT::with_capacity(alloc_len);
-                heap_buf.as_uninit_slice_mut()
-            };
+            cfg_if! {
+                if #[cfg(target_pointer_width = "16")] {
+                    let heap_buf = BufT::with_capacity(alloc_len);
+                    let scratch = heap_buf.as_uninit_slice_mut();
+                } else {
+                    // For small inputs 4KiB of stack storage suffices, which allows us to avoid
+                    // calling the (de-)allocator. Benchmarks showed this was quite beneficial.
+                    let mut stack_buf = AlignedStorage::<T, 4096>::new();
+                    let stack_scratch = stack_buf.as_uninit_slice_mut();
+                    let mut heap_buf;
+                    let scratch = if stack_scratch.len() >= alloc_len {
+                        stack_scratch
+                    } else {
+                        heap_buf = BufT::with_capacity(alloc_len);
+                        heap_buf.as_uninit_slice_mut()
+                    };
+                }
+            }
 
             tiny::mergesort(v, scratch, is_less);
         } else {
diff --git a/core/src/slice/sort/unstable/mod.rs b/core/src/slice/sort/unstable/mod.rs
@@ -31,7 +31,7 @@ pub fn sort<T, F: FnMut(&T, &T) -> bool>(v: &mut [T], is_less: &mut F) {
     }
 
     cfg_if! {
-        if #[cfg(feature = "optimize_for_size")] {
+        if #[cfg(any(feature = "optimize_for_size", target_pointer_width = "16"))] {
             heapsort::heapsort(v, is_less);
         } else {
             // More advanced sorting methods than insertion sort are faster if called in

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ pub fn sort<T, F: FnMut(&T, &T) -> bool>(v: &mut [T], is_less: &mut F) {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`cfg_if! {`
`34`		`- if #[cfg(feature = "optimize_for_size")] {`
	`34`	`+ if #[cfg(any(feature = "optimize_for_size", target_pointer_width = "16"))] {`
`35`	`35`	`heapsort::heapsort(v, is_less);`
`36`	`36`	`} else {`
`37`	`37`	`// More advanced sorting methods than insertion sort are faster if called in`