Struct LQueue 

pub struct LQueue { /* private fields */ }

The operation queue that records and executes parallel operations.

LQueue is the central coordinator for deferred parallel execution. It manages the recording of operations and their bulk execution, minimizing thread pool overhead by batching all operations together.

Workflow

1. Create vectors with LQueue::lvec or LQueue::lvec_with_capacity
2. Call LQueue::start to begin recording
3. Perform operations on LVec instances (all operations are recorded, not executed)
4. Call LQueue::end to execute all recorded operations in parallel
5. Use LVec::materialize to retrieve results

Type Agnostic

A single LQueue can manage vectors of different types simultaneously:

use leopard::{LQueue, LVec};

let q = LQueue::new();
let integers: LVec<i32> = q.lvec_with_capacity(100);
let floats: LVec<f64> = q.lvec_with_capacity(100);
// Both can be used in the same recording session

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(1000);
let y: LVec<f64> = q.lvec_with_capacity(1000);

q.start();
let x = x.fill_with(|i| i as f64);
let y = y.fill_with(|i| (i * 2) as f64);
let z = &x + &y;
q.end();

let result = z.materialize().unwrap();
println!("Sum: {:?}", &result[0..5]);

Implementations

impl LQueue

pub fn new() -> Self

Creates a new operation queue.

Examples

use leopard::LQueue;

let q = LQueue::new();

pub fn lvec<T>(&self) -> LVec<T>

where T: Clone + Send + Sync + Default + 'static,

Creates a new LVec with the default capacity (128 elements).

Type Parameters

• T - The element type, must implement Clone + Send + Sync + Default

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let vec: LVec<f64> = q.lvec();
assert_eq!(vec.capacity(), 128);

pub fn lvec_with_capacity<T>(&self, capacity: usize) -> LVec<T>

where T: Clone + Send + Sync + Default + 'static,

Creates a new LVec with the specified capacity.

Arguments

• capacity - The number of elements the vector can hold

Type Parameters

• T - The element type, must implement Clone + Send + Sync + Default

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let vec: LVec<f64> = q.lvec_with_capacity(10000);
assert_eq!(vec.capacity(), 10000);

pub fn start(&self)

Starts recording operations.

After calling start(), all operations on LVec instances created from this queue will be recorded rather than executed. The operations will be executed when LQueue::end is called.

Panics

Operations on LVec will panic if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(100);

q.start();  // Begin recording
let x = x.fill(42.0);
// ... more operations ...
q.end();    // Execute all recorded operations

pub fn end(&self)

Stops recording and executes all recorded operations in parallel.

This method executes all operations that were recorded since the last LQueue::start call. Operations are executed in dependency order, with independent operations running in parallel.

After end() is called, results can be retrieved using LVec::materialize.

Performance

All parallel execution happens in this single call, minimizing thread pool creation overhead compared to executing operations individually.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(1000);

q.start();
let x = x.fill_with(|i| i as f64);
let y = x.map(|_, v| v * 2.0);
q.end();  // Both fill and map execute here

let result = y.materialize().unwrap();

pub fn is_recording(&self) -> bool

Returns true if the queue is currently recording operations.

Examples

use leopard::LQueue;

let q = LQueue::new();
assert!(!q.is_recording());

q.start();
assert!(q.is_recording());

q.end();
assert!(!q.is_recording());

Trait Implementations

impl Clone for LQueue

fn clone(&self) -> LQueue

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for LQueue

fn default() -> Self

Returns the “default value” for a type.