Struct Pool 

pub struct Pool<'p> { /* private fields */ }

A wrapper around a host’s borrowed, owned or shared Rayon pool.

tcontract never creates threads beyond this pool. Its size is fixed at construction (Rayon pools cannot resize). The embedded mutex serializes SPMD broadcasts through this wrapper. Hosts sharing a raw pool must retain one wrapper and serialize potentially conflicting numerical work, rather than constructing independent wrappers with separate SPMD mutexes.

Examples

let tp = rayon::ThreadPoolBuilder::new().num_threads(3).build().unwrap();
let pool = tcontract_exec::Pool::borrow(&tp);
assert_eq!(pool.size(), 3);
assert_eq!(pool.stats().entries, 0);

Implementations

impl<'p> Pool<'p>

pub fn borrow(pool: &'p ThreadPool) -> Self

Borrow a host pool.

pub fn workspace(&self) -> &ArenaProvider

The storage this pool lends to every operation that runs on it.

Borrowed, not copied: one pool is one owner, and a driver that is given this provider returns its team sets to it on drop.

pub fn trim_workspace(&self)

Release the pool’s idle workspace storage. Live leases and borrowed worker buffers survive; a worker parked on this pool keeps its slot until it is idle again.

pub fn size(&self) -> usize

Number of workers.

pub fn rayon_pool(&self) -> &ThreadPool

The raw Rayon pool this wrapper wraps.

For a provider that takes a rayon::ThreadPool directly (faer through tlinalg, LAPACK) and must run on the host’s pool rather than a second one. The wrapper’s retained workspace and its SPMD gate stay with the wrapper: a provider that takes the bare pool does not share them, so a host that mixes such a provider with this stack keeps one pool but two workspace owners.

pub fn into_owned(self) -> Option<ThreadPool>

Give back an owned pool (None for a borrowed or shared one), for example so a C host can drop it and join its workers. A shared wrapper releases only its Arc reference; other owners keep the raw pool alive.

pub fn stats(&self) -> PoolStats

Snapshot of the entry counters.

pub fn reset_stats(&self)

Zero the counters.

impl Pool<'static>

pub fn shared(pool: Arc<ThreadPool>) -> Self

Share the host’s existing Rayon pool without creating another worker team.

Retain this wrapper across calls and share it (for example through an Arc<Pool<'static>>) across host clones to reuse workspace and SPMD serialization. Other numerical libraries may borrow the host’s original raw pool, but their work must obey the host’s same resource-loan protocol.

Examples

use std::sync::Arc;
let raw = Arc::new(rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap());
let pool = tcontract_exec::Pool::shared(Arc::clone(&raw));
assert_eq!(pool.size(), raw.current_num_threads());

pub fn owned(pool: ThreadPool) -> Self

Take ownership of a pool, for hosts without one of their own (the C ABI’s tcontract_tapp_executor_create_rayon). Rust hosts normally Pool::borrow.

Examples

let tp = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap();
let pool = tcontract_exec::Pool::owned(tp);
assert_eq!(pool.size(), 2);

Trait Implementations

impl Debug for Pool<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.