Struct GraphDevices 

pub struct GraphDevices { /* private fields */ }

A graph plus lazy per-device compiled executables.

Implementations

impl GraphDevices

pub fn new(graph: Graph) -> Self

pub fn with_policy(graph: Graph, policy: DevicePolicy) -> Self

pub fn from_env(graph: Graph) -> Self

pub fn policy(&self) -> &DevicePolicy

pub fn graph(&self) -> &Graph

pub fn devices(&self) -> &[Device]

pub fn report(&self) -> Vec<DeviceCandidate>

pub fn fastest(&self) -> Device

pub fn resolve(&self, hint: Option<Device>) -> Result<Device, String>

pub fn resolve_chain(&self, hint: Option<Device>) -> Result<Device, String>

Resolve using RLX_DEVICE_CHAIN when set, else Self::resolve.

pub fn set_param(&mut self, name: &str, data: &[f32])

Upload a param to every cached executor and future compilations.

pub fn set_param_typed(&mut self, name: &str, data: &[u8], dtype: DType)

Typed param upload — mirrored to all cached backends.

pub fn sync_params_to_all(&mut self)

Re-apply stored params to all cached backends (after manual cache changes).

pub fn resolve_with_inputs( &mut self, hint: Option<Device>, inputs: &[(&str, &[f32])], ) -> Result<Device, String>

Hint → env → cost model, or micro-benchmark when policy requests it.

pub fn compile(&mut self, device: Device) -> Result<&mut CompiledGraph, String>

pub fn compile_fastest(&mut self) -> Result<&mut CompiledGraph, String>

pub fn compile_resolved( &mut self, hint: Option<Device>, ) -> Result<&mut CompiledGraph, String>

pub fn compile_chain( &mut self, hint: Option<Device>, ) -> Result<&mut CompiledGraph, String>

pub fn warm_all(&mut self) -> Result<Vec<Device>, String>

pub fn benchmark( &mut self, inputs: &[(&str, &[f32])], runs: usize, ) -> Result<Vec<DeviceBenchResult>, String>

pub fn run( &mut self, device: Device, inputs: &[(&str, &[f32])], ) -> Result<Vec<Vec<f32>>, String>

pub fn run_resolved( &mut self, hint: Option<Device>, inputs: &[(&str, &[f32])], ) -> Result<Vec<Vec<f32>>, String>

pub fn run_fastest( &mut self, inputs: &[(&str, &[f32])], ) -> Result<Vec<Vec<f32>>, String>

pub fn run_try( &mut self, chain: &[Device], inputs: &[(&str, &[f32])], ) -> Result<(Device, Vec<Vec<f32>>), DeviceFallbackError>

Try chain in order until one backend compiles and runs successfully.

pub fn run_chain( &mut self, hint: Option<Device>, inputs: &[(&str, &[f32])], ) -> Result<(Device, Vec<Vec<f32>>), DeviceFallbackError>

Like Self::run_try using RLX_DEVICE_CHAIN when set.

pub fn compile_resolved_with_inputs( &mut self, hint: Option<Device>, inputs: &[(&str, &[f32])], ) -> Result<&mut CompiledGraph, String>

pub fn run_resolved_with_inputs( &mut self, hint: Option<Device>, inputs: &[(&str, &[f32])], ) -> Result<Vec<Vec<f32>>, String>

pub fn invalidate_cache(&mut self)

pub fn set_policy(&mut self, policy: DevicePolicy)