initial commit

src/par.rs

@@ -0,0 +1,48 @@
+//! Tiny data-parallel primitive shared across the crate — no work-stealing dependency, just scoped
+//! threads pulling work by an atomic index. Lives in the library (not the binary) so lib modules
+//! (`xref`, …) and the CI pipeline can parallelise directly, not only the CLI front-end.
+
+use std::sync::Mutex;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// Run `f` over `items` across `nthreads` scoped threads, pulling work by atomic index
+/// (dynamic load-balancing without a work-stealing dep). Results returned in input order, so callers
+/// that merge them stay deterministic regardless of which thread finished which item.
+pub fn parallel_map<T, R, F>(items: &[T], nthreads: usize, f: F) -> Vec<R>
+where
+    T: Sync,
+    R: Send,
+    F: Fn(&T) -> R + Sync,
+{
+    let len = items.len();
+    let nthreads = nthreads.clamp(1, len.max(1));
+    let next = AtomicUsize::new(0);
+    let out: Mutex<Vec<(usize, R)>> = Mutex::new(Vec::with_capacity(len));
+    std::thread::scope(|s| {
+        for _ in 0..nthreads {
+            s.spawn(|| {
+                let mut local = Vec::new();
+                loop {
+                    let i = next.fetch_add(1, Ordering::Relaxed);
+                    if i >= len {
+                        break;
+                    }
+                    local.push((i, f(&items[i])));
+                }
+                out.lock().unwrap().extend(local);
+            });
+        }
+    });
+    let mut v = out.into_inner().unwrap();
+    v.sort_by_key(|(i, _)| *i);
+    v.into_iter().map(|(_, r)| r).collect()
+}
+
+/// Requested thread count, or the machine's available parallelism.
+pub fn default_threads(threads: Option<usize>) -> usize {
+    threads.unwrap_or_else(|| {
+        std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(4)
+    })
+}