prgress

Author: flexatone

Cargo.lock

@@ -10,4 +10,19 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = "0.25.0"
-numpy = "0.25.0"
+numpy = "0.25.0"
+wide = "0.7.33"
+
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+
+[profile.dev]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+
+[build]
+rustflags = ["-C", "target-cpu=native"]

Cargo.toml

@@ -10,7 +10,12 @@
 from arraykit import first_true_1d as ak_first_true_1d
 import arraykit as ak
 
-from arrayredox import first_true_1d as ar_first_true_1d
+from arrayredox import first_true_1d_a as ar_first_true_1d_a
+from arrayredox import first_true_1d_b as ar_first_true_1d_b
+from arrayredox import first_true_1d_c as ar_first_true_1d_c
+from arrayredox import first_true_1d_d as ar_first_true_1d_d
+from arrayredox import first_true_1d_e as ar_first_true_1d_e
+from arrayredox import first_true_1d_f as ar_first_true_1d_f
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -35,13 +40,55 @@ class AKFirstTrue(ArrayProcessor):
     def __call__(self):
         _ = ak_first_true_1d(self.array, forward=True)
 
-class ARFirstTrue(ArrayProcessor):
-    NAME = 'ar.first_true_1d()'
+class ARFirstTrueA(ArrayProcessor):
+    NAME = 'ar.first_true_1d_a()'
     SORT = 0
 
     def __call__(self):
         # _ = ar_first_true_1d(self.array, forward=True)
-        _ = ar_first_true_1d(self.array)
+        _ = ar_first_true_1d_a(self.array)
+
+class ARFirstTrueB(ArrayProcessor):
+    NAME = 'ar.first_true_1d_b()'
+    SORT = 0
+
+    def __call__(self):
+        # _ = ar_first_true_1d(self.array, forward=True)
+        _ = ar_first_true_1d_b(self.array)
+
+class ARFirstTrueC(ArrayProcessor):
+    NAME = 'ar.first_true_1d_c()'
+    SORT = 0
+
+    def __call__(self):
+        # _ = ar_first_true_1d(self.array, forward=True)
+        _ = ar_first_true_1d_c(self.array)
+
+class ARFirstTrueD(ArrayProcessor):
+    NAME = 'ar.first_true_1d_d()'
+    SORT = 0
+
+    def __call__(self):
+        # _ = ar_first_true_1d(self.array, forward=True)
+        _ = ar_first_true_1d_d(self.array)
+
+class ARFirstTrueE(ArrayProcessor):
+    NAME = 'ar.first_true_1d_e()'
+    SORT = 0
+
+    def __call__(self):
+        # _ = ar_first_true_1d(self.array, forward=True)
+        _ = ar_first_true_1d_e(self.array)
+
+class ARFirstTrueF(ArrayProcessor):
+    NAME = 'ar.first_true_1d_f()'
+    SORT = 0
+
+    def __call__(self):
+        # _ = ar_first_true_1d(self.array, forward=True)
+        _ = ar_first_true_1d_f(self.array)
+
+
 
 
 class PYLoop(ArrayProcessor):
@@ -77,7 +124,7 @@ def __call__(self):
         _ = np.argmax(self.array)
 
 #-------------------------------------------------------------------------------
-NUMBER = 100
+NUMBER = 10000
 
 def seconds_to_display(seconds: float) -> str:
     seconds /= NUMBER
@@ -258,9 +305,14 @@ def get_versions() -> str:
 
 CLS_PROCESSOR = (
     AKFirstTrue,
-    ARFirstTrue,
-    NPNonZero,
+    # ARFirstTrueA,
+    # ARFirstTrueB,
+    # ARFirstTrueC,
+    # ARFirstTrueD,
+    ARFirstTrueE,
+    ARFirstTrueF,
     NPArgMax,
+    # NPNonZero,
     # NPNotAnyArgMax,
     # PYLoop,
     )

doc/articles/first_true_1d.py

@@ -1,17 +1,192 @@
 use pyo3::prelude::*;
-use numpy::PyReadonlyArray1;
+use wide::*;
+use numpy::{PyReadonlyArray1};
 
 #[pyfunction]
-fn first_true_1d(array: PyReadonlyArray1<bool>) -> isize {
+fn first_true_1d_a(array: PyReadonlyArray1<bool>) -> isize {
     match array.as_slice() {
         Ok(slice) => slice.iter().position(|&v| v).map(|i| i as isize).unwrap_or(-1),
         Err(_) => -1, // Should not happen for 1D arrays, but fallback to -1
     }
 }
 
+// Release the GIL, still doing slice iteration
+#[pyfunction]
+fn first_true_1d_b(py: Python, array: PyReadonlyArray1<bool>) -> isize {
+    if let Ok(slice) = array.as_slice() {
+        py.allow_threads(|| {
+            for (i, &value) in slice.iter().enumerate() {
+                if value {
+                    return i as isize;
+                }
+            }
+            -1
+        })
+    } else {
+        let array_view = array.as_array();
+        py.allow_threads(|| {
+            for (idx, &val) in array_view.iter().enumerate() {
+                if val {
+                    return idx as isize;
+                }
+            }
+            -1
+        })
+    }
+}
+
+#[pyfunction]
+fn first_true_1d_c(array: PyReadonlyArray1<bool>) -> isize {
+    if let Ok(slice) = array.as_slice() {
+        let len = slice.len();
+        let mut i = 0;
+
+        // Process 8 elements at a time
+        while i + 8 <= len {
+            if slice[i] { return i as isize; }
+            if slice[i+1] { return (i+1) as isize; }
+            if slice[i+2] { return (i+2) as isize; }
+            if slice[i+3] { return (i+3) as isize; }
+            if slice[i+4] { return (i+4) as isize; }
+            if slice[i+5] { return (i+5) as isize; }
+            if slice[i+6] { return (i+6) as isize; }
+            if slice[i+7] { return (i+7) as isize; }
+            i += 8;
+        }
+
+        // Handle remainder
+        while i < len {
+            if slice[i] { return i as isize; }
+            i += 1;
+        }
+        -1
+    } else {
+        array.as_array().iter().position(|&v| v).map(|i| i as isize).unwrap_or(-1)
+    }
+}
+
+
+#[pyfunction]
+fn first_true_1d_d(array: PyReadonlyArray1<bool>) -> isize {
+    if let Ok(slice) = array.as_slice() {
+        let len = slice.len();
+        let mut i = 0;
+
+        unsafe {
+            // Process 8 elements at a time
+            while i + 8 <= len {
+                if *slice.get_unchecked(i) { return i as isize; }
+                if *slice.get_unchecked(i+1) { return (i+1) as isize; }
+                if *slice.get_unchecked(i+2) { return (i+2) as isize; }
+                if *slice.get_unchecked(i+3) { return (i+3) as isize; }
+                if *slice.get_unchecked(i+4) { return (i+4) as isize; }
+                if *slice.get_unchecked(i+5) { return (i+5) as isize; }
+                if *slice.get_unchecked(i+6) { return (i+6) as isize; }
+                if *slice.get_unchecked(i+7) { return (i+7) as isize; }
+                i += 8;
+            }
+
+            // Handle remainder
+            while i < len {
+                if *slice.get_unchecked(i) { return i as isize; }
+                i += 1;
+            }
+        }
+        -1
+    } else {
+        array.as_array().iter().position(|&v| v).map(|i| i as isize).unwrap_or(-1)
+    }
+}
+
+
+#[pyfunction]
+fn first_true_1d_e(array: PyReadonlyArray1<bool>) -> isize {
+    if let Ok(slice) = array.as_slice() {
+        let len = slice.len();
+        let ptr = slice.as_ptr() as *const u8;
+
+        unsafe {
+            // Process 8 bytes at a time as u64
+            let mut i = 0;
+            while i + 8 <= len {
+                // Check 8 bytes at once
+                let chunk = *(ptr.add(i) as *const u64);
+                if chunk != 0 {
+                    // Found a true value in this chunk, check each byte
+                    for j in 0..8 {
+                        if i + j < len && *ptr.add(i + j) != 0 {
+                            return (i + j) as isize;
+                        }
+                    }
+                }
+                i += 8;
+            }
+
+            // Handle remainder
+            while i < len {
+                if *ptr.add(i) != 0 {
+                    return i as isize;
+                }
+                i += 1;
+            }
+        }
+        -1
+    } else {
+        array.as_array().iter().position(|&v| v).map(|i| i as isize).unwrap_or(-1)
+    }
+}
+
+
+#[pyfunction]
+fn first_true_1d_f(py: Python, array: PyReadonlyArray1<bool>) -> isize {
+    if let Ok(slice) = array.as_slice() {
+        py.allow_threads(|| {
+            let len = slice.len();
+            let ptr = slice.as_ptr() as *const u8;
+            let mut i = 0;
+
+            let ones = u8x32::splat(1);
+            unsafe {
+                // Process 32 bytes at a time with SIMD
+                while i + 32 <= len {
+                    // Cast pointer to array reference
+                    let bytes = &*(ptr.add(i) as *const [u8; 32]);
+
+                    // Convert to SIMD vector
+                    let chunk = u8x32::from(*bytes);
+                    let equal_one = chunk.cmp_eq(ones);
+                    if equal_one.any() {
+                        break;
+                    }
+
+                    i += 32;
+                }
+                // // Handle final remainder
+                while i < len.min(i + 32) {
+                    if *ptr.add(i) != 0 {
+                        return i as isize;
+                    }
+                    i += 1;
+                }
+                -1
+            }
+        })
+    } else {
+        let array_view = array.as_array();
+        py.allow_threads(|| {
+            array_view.iter().position(|&v| v).map(|i| i as isize).unwrap_or(-1)
+        })
+    }
+}
+
 
 #[pymodule]
 fn arrayredox(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(first_true_1d, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_a, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_b, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_c, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_d, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_e, m)?)?;
+    m.add_function(wrap_pyfunction!(first_true_1d_f, m)?)?;
     Ok(())
 }