Struct UnifiedExecutor 

pub struct UnifiedExecutor { /* private fields */ }

Unified executor for heterogeneous device execution.

Manages device contexts to enable parallel execution across any mix of devices. Uses timeline signals for cross-device synchronization.

Stateless Execution Model (Tinygrad-Aligned)

The executor follows Tinygrad’s stateless execution model where:

• Dependencies are computed at schedule time, not runtime
• ExecutionPlan pre-computes kernel order via topological sort
• No runtime dependency tracking is needed (zero memory accumulation)
• Timeline signals handle cross-device synchronization only

Implementations

impl UnifiedExecutor

pub fn new(registry: &'static DeviceRegistry) -> Self

Create a new unified executor.

pub fn add_device(&mut self, device_spec: DeviceSpec) -> Result<()>

Add a device to the executor.

Creates the device context with timeline signal and queues.

pub fn context(&self, device: &DeviceSpec) -> Option<&DeviceContext>

Get the device context for a device specification.

pub fn context_mut(&mut self, device: &DeviceSpec) -> Option<&mut DeviceContext>

Get the device context mutably.

pub fn sync_strategy(from: &DeviceSpec, to: &DeviceSpec) -> SyncStrategy

Determine the synchronization strategy between two devices.

pub fn single_device_check(&self, buffers: &[&Buffer]) -> Option<DeviceSpec>

Check if all operations on a single device.

Returns Some(device) if all buffers are on the same device, enabling the fast single-device path.

pub fn synchronize_all(&self) -> Result<()>

Synchronize all devices.

Waits for all pending operations to complete on all devices.

pub fn execute_kernel<F>( &mut self, device: &DeviceSpec, execute_fn: F, ) -> Result<u64>

where F: FnOnce() -> Result<()>,

Execute a kernel (sequential execution).

ExecutionPlan pre-computes kernel order at schedule time, so no runtime dependency tracking is needed. This follows Tinygrad’s stateless execution model.

Arguments

• device - Device to execute on
• execute_fn - Function that performs the actual kernel execution

Returns

The timeline value for this execution (can be used for cross-device sync).

pub fn execute_transfer( &mut self, src: &Buffer, dst: &mut Buffer, src_device: &DeviceSpec, dst_device: &DeviceSpec, ) -> Result<u64>

Execute a buffer transfer (COPY operation).

Handles cross-device transfers with appropriate synchronization:

• Same device: Direct copy using device’s copy queue
• Same vendor (e.g., CUDA:0 → CUDA:1): Peer-to-peer transfer
• Different vendors (e.g., CUDA → CPU): Stage through host memory

Arguments

• src - Source buffer
• dst - Destination buffer (must be pre-allocated)
• src_device - Device the source buffer is on
• dst_device - Device the destination buffer is on

Returns

The timeline value for this transfer operation.

Trait Implementations

impl Debug for UnifiedExecutor

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

Formats the value using the given formatter.