#[cfg(all(feature = "enc", feature = "parallel-encode"))]
mod imp {
extern crate std;
use alloc::vec::Vec;
use core::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{OnceLock, mpsc};
fn workers() -> usize {
static WORKERS: OnceLock<usize> = OnceLock::new();
*WORKERS.get_or_init(|| {
let asked = std::env::var("EMBARK_ENCODE_THREADS")
.ok()
.and_then(|v| v.trim().parse::<usize>().ok());
match asked {
Some(n) if n > 0 => n,
_ => std::thread::available_parallelism().map_or(1, |n| n.get()),
}
})
}
fn spare() -> &'static AtomicUsize {
static SPARE: OnceLock<AtomicUsize> = OnceLock::new();
SPARE.get_or_init(|| AtomicUsize::new(workers() - 1))
}
fn reserve(want: usize) -> usize {
let spare = spare();
let mut free = spare.load(Ordering::Relaxed);
loop {
let take = want.min(free);
if take == 0 {
return 0;
}
match spare.compare_exchange_weak(
free,
free - take,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => return take,
Err(now) => free = now,
}
}
}
fn claim(next: &AtomicUsize, len: usize) -> Option<usize> {
let index = next.fetch_add(1, Ordering::Relaxed);
(index < len).then_some(index)
}
struct Loan(usize);
impl Drop for Loan {
fn drop(&mut self) {
spare().fetch_add(self.0, Ordering::Relaxed);
}
}
pub fn map<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(&T) -> R + Sync,
{
let len = items.len();
let extra = if len < 2 { 0 } else { reserve(len - 1) };
if extra == 0 {
return items.iter().map(f).collect();
}
let loan = Loan(extra);
let next = AtomicUsize::new(0);
let (tx, rx) = mpsc::channel();
std::thread::scope(|scope| {
for _ in 0..extra {
let tx = tx.clone();
let (next, f) = (&next, &f);
scope.spawn(move || {
while let Some(index) = claim(next, len) {
let _ = tx.send((index, f(&items[index])));
}
});
}
while let Some(index) = claim(&next, len) {
let _ = tx.send((index, f(&items[index])));
}
drop(tx);
});
drop(loan);
let mut slots: Vec<Option<R>> = (0..len).map(|_| None).collect();
for (index, value) in rx {
slots[index] = Some(value);
}
slots
.into_iter()
.map(|slot| slot.expect("every index was claimed exactly once"))
.collect()
}
}
#[cfg(not(all(feature = "enc", feature = "parallel-encode")))]
mod imp {
use alloc::vec::Vec;
pub fn map<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(&T) -> R + Sync,
{
items.iter().map(f).collect()
}
}
pub use imp::map;