use forkunion::*;
// One pool per compute domain, sized to that domain's core count.
let topology = Topology::new().unwrap();
let pools: Vec<ThreadPool> = (0..topology.compute_domains_count().unwrap())
    .map(|c| ThreadPool::spawn_on(&topology, c, topology.logical_cores_count_in(ComputeDomain(c)).unwrap_or(1), CallerExclusivity::Exclusive).unwrap())
    .collect();
assert_eq!(pools.len(), topology.compute_domains_count().unwrap());

• threads - Total number of threads including the caller thread

use forkunion::*;

// Create a pool that uses 4 threads total (3 spawned + caller)
let topology = Topology::new().unwrap();
let pool = ThreadPool::spawn(&topology, 4).expect("Failed to create thread pool");
assert_eq!(pool.threads_count(), 4);

• name - Name for the thread pool, up to 15 characters
• threads - Total number of threads including the caller thread

use forkunion::*;

let topology = Topology::new().unwrap();
let pool = ThreadPool::named_spawn(&topology, "worker_pool", 4).expect("Failed to create thread pool");
assert_eq!(pool.threads_count(), 4);

• compute_domain_index - The compute_domain to query (0-based)

use forkunion::*;

let topology = Topology::new().unwrap();
let pool = spawn(&topology, 8);
let total_compute_domains = pool.compute_domains_count();

for compute_domain_index in 0..total_compute_domains {
    let thread_count = pool.threads_count_in(compute_domain_index);
    println!("ComputeDomain {} has {} threads", compute_domain_index, thread_count);
}

• global_thread_index - The global thread index to convert
• compute_domain_index - The compute_domain to get the local index for

• micros - Wake-up check interval in microseconds, must be > 0

This function is not thread-safe and should only be called between task batches when no parallel operations are in progress.

use forkunion::*;

let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);

// Process a batch of work
pool.for_n(1000, |task, _at| {
    // Do some work...
    std::hint::black_box(task * 2);
});

// Put threads to sleep between batches to save power, until the next dispatch
pool.sleep(0);

// Process another batch
pool.for_n(500, |task, _at| {
    std::hint::black_box(task * 3);
});

• function - Closure executed on each thread, receiving (thread_index, compute_domain_index).
• caller - Closure the calling thread runs with the dispatch underway; its result is returned.

use forkunion::*;

let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);
pool.for_threads(
    |thread_index, compute_domain_index| {
        println!("Thread {} on compute_domain {}", thread_index, compute_domain_index);
    },
    |operation| operation.join(),
);

The guard is only lent, so it cannot be leaked past the dispatch:

use forkunion::*;
let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 2);
let escaped = pool.for_threads(|_, _| {}, |operation| operation);

use forkunion::*;
let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);
let counter = std::sync::atomic::AtomicUsize::new(0);
pool.broadcast(|_thread_index, _compute_domain_index| {
    counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
});
assert_eq!(counter.load(std::sync::atomic::Ordering::Relaxed), pool.threads_count());

use forkunion::*;
let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);
let counter = SpinMutex::new(0usize);
pool.scope(|scope| {
    let view = scope.view();
    scope.broadcast(|thread_index, compute_domain_index| {
        let _local = view.locate_thread_in(thread_index, compute_domain_index);
        *counter.lock() += 1;
    });
});
assert_eq!(*counter.lock(), pool.threads_count());

• n - Total number of tasks to distribute
• function - Closure executed for each run, given its ThreadInDomain and a TasksRange

use forkunion::*;

let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);

pool.for_slices(1000, |range, at| {
    // Each thread gets one contiguous run, which iterates directly
    for task in range {
        std::hint::black_box(task * task);
    }

    println!("Thread {} processed run [{}, {})", at.thread, range.first, range.end());
});

use forkunion::*;
let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);
let mut data = vec![0u64; 1000];
pool.for_slices_mut(&mut data, |chunk, _at| {
    for value in chunk {
        *value += 1;
    }
});
assert!(data.iter().all(|&value| value == 1));

• n - Total number of tasks to distribute
• function - Closure executed for each task, given the task index and its ThreadInDomain

use forkunion::*;

let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);

pool.for_n(1000, |task, _at| {
    // Simulate computation based on task index
    let result = task * task;
    std::hint::black_box(result); // Prevent optimization
});

• n - Total number of tasks to distribute
• function - Closure executed for each task, given the task index and its ThreadInDomain

use forkunion::*;

let topology = Topology::new().unwrap();
let mut pool = spawn(&topology, 4);

pool.for_n_dynamic(100, |task, _at| {
    // Simulate variable work duration - some tasks take longer
    let iterations = if task % 10 == 0 { 10000 } else { 100 };
    for i in 0..iterations {
        std::hint::black_box(task * i);
    }
});

• Only one thread may operate the pool at a time, and only one dispatch may be in flight: unsafe_join must complete before the next dispatch or pool destruction.
• callback and context must remain valid until unsafe_join returns.

Must be called on the thread operating the pool; the dispatched callback and context must still be valid.

The caller must ensure that:

• The index is within bounds of the allocated data
• The data at the index is properly initialized
• The data remains valid for the lifetime of the returned reference

• index - The index of the element to access

The caller must ensure:

• The index is within the bounds of the original allocation
• No overlapping mutable access occurs from multiple threads
• Each thread accesses disjoint indices when used concurrently
• The pointer remains valid for the duration of access

• tasks_count - Total number of tasks to distribute
• threads_count - Number of threads to distribute across (must be > 0)

Panics if threads_count is zero.