Struct LoomRuntime 

pub struct LoomRuntime { /* private fields */ }

A bespoke thread pool runtime combining tokio and rayon with CPU pinning.

The runtime provides:

• A tokio async runtime for I/O-bound work
• A rayon thread pool for CPU-bound parallel work
• Automatic CPU pinning for both runtimes
• A task tracker for graceful shutdown
• Zero-allocation compute spawning after warmup

Performance Guarantees

Method	Overhead	Allocations	Tracked
spawn_async()	~10ns	Token only	Yes
spawn_compute()	~100-500ns	0 bytes (after warmup)	Yes
install()	~0ns	None	No
rayon_pool()	0ns	None	No
tokio_handle()	0ns	None	No

Examples

use loom_rs::LoomBuilder;

let runtime = LoomBuilder::new()
    .prefix("myapp")
    .tokio_threads(2)
    .rayon_threads(6)
    .build()?;

runtime.block_on(async {
    // Spawn tracked async I/O task
    let io_handle = runtime.spawn_async(async {
        fetch_data().await
    });

    // Spawn tracked compute task and await result
    let result = runtime.spawn_compute(|| {
        expensive_computation()
    }).await;

    // Zero-overhead parallel iterators (within tracked context)
    let processed = runtime.install(|| {
        data.par_iter().map(|x| process(x)).collect()
    });
});

// Graceful shutdown from main thread
runtime.block_until_idle();

Implementations

impl LoomRuntime

pub fn config(&self) -> &LoomConfig

Get the resolved configuration.

pub fn tokio_handle(&self) -> &Handle

Get the tokio runtime handle.

This can be used to spawn untracked tasks or enter the runtime context. For tracked async tasks, prefer spawn_async().

Performance

Zero overhead - returns a reference.

pub fn rayon_pool(&self) -> &ThreadPool

Get the rayon thread pool.

This can be used to execute parallel iterators or spawn untracked work directly. For tracked compute tasks, prefer spawn_compute(). For zero-overhead parallel iterators, prefer install().

Performance

Zero overhead - returns a reference.

pub fn task_tracker(&self) -> &TaskTracker

Get the task tracker for graceful shutdown.

Use this to track spawned tasks and wait for them to complete.

pub fn block_on<F: Future>(&self, f: F) -> F::Output

Block on a future using the tokio runtime.

This is the main entry point for running async code from the main thread. The current runtime is available via loom_rs::current_runtime() within the block_on scope.

Examples

runtime.block_on(async {
    // Async code here
    // loom_rs::current_runtime() works here
});

pub fn spawn_async<F>(&self, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a tracked async task on tokio.

The task is tracked for graceful shutdown via block_until_idle().

Performance

Overhead: ~10ns (TaskTracker token only).

Examples

runtime.block_on(async {
    let handle = runtime.spawn_async(async {
        // I/O-bound async work
        fetch_data().await
    });

    let result = handle.await.unwrap();
});

pub async fn spawn_compute<F, R>(&self, f: F) -> R

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Spawn CPU-bound work on rayon and await the result.

The task is tracked for graceful shutdown via block_until_idle(). Automatically uses per-type object pools for zero allocation after warmup.

Performance

State	Allocations	Overhead
Pool hit	0 bytes	~100-500ns
Pool miss	~32 bytes	~100-500ns
First call per type	Pool + state	~1µs

For zero-overhead parallel iterators (within an already-tracked context), use install() instead.

Examples

runtime.block_on(async {
    let result = runtime.spawn_compute(|| {
        // CPU-intensive work
        expensive_computation()
    }).await;
});

pub fn install<F, R>(&self, f: F) -> R

where F: FnOnce() -> R + Send, R: Send,

Execute work on rayon with zero overhead (sync, blocking).

This installs the rayon pool for the current scope, allowing direct use of rayon’s parallel iterators.

NOT tracked - use within an already-tracked task (e.g., inside spawn_async or spawn_compute) for proper shutdown tracking.

Performance

Zero overhead - direct rayon access.

Examples

runtime.block_on(async {
    // This is a tracked context (we're in block_on)
    let processed = runtime.install(|| {
        use rayon::prelude::*;
        data.par_iter().map(|x| process(x)).collect::<Vec<_>>()
    });
});

pub fn shutdown(&self)

Stop accepting new tasks.

After calling this, spawn_async() and spawn_compute() will still work, but the shutdown process has begun. Use is_idle() or wait_for_shutdown() to check/wait for completion.

pub fn is_idle(&self) -> bool

Check if all tracked tasks have completed.

Returns true if shutdown() has been called and all tracked async tasks and compute tasks have finished.

Performance

Zero overhead - single atomic load.

pub fn compute_tasks_in_flight(&self) -> usize

Get the number of compute tasks currently in flight.

Useful for debugging shutdown issues or monitoring workload.

Example

if runtime.compute_tasks_in_flight() > 0 {
    tracing::warn!("Still waiting for {} compute tasks",
        runtime.compute_tasks_in_flight());
}

pub async fn wait_for_shutdown(&self)

Wait for all tracked tasks to complete (async).

Call from within block_on(). Requires shutdown() to be called first, otherwise this will wait forever.

Examples

runtime.block_on(async {
    runtime.spawn_async(work());
    runtime.shutdown();
    runtime.wait_for_shutdown().await;
});

pub fn block_until_idle(&self)

Block until all tracked tasks complete (from main thread).

This is the primary shutdown method. It:

1. Calls shutdown() to close the task tracker
2. Waits for all tracked async and compute tasks to finish

Examples

runtime.block_on(async {
    runtime.spawn_async(background_work());
    runtime.spawn_compute(|| cpu_work());
});

// Graceful shutdown from main thread
runtime.block_until_idle();

Trait Implementations

impl Debug for LoomRuntime

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

Formats the value using the given formatter.

impl Display for LoomRuntime

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

Formats the value using the given formatter.