Struct XlaExecutor 

pub struct XlaExecutor { /* private fields */ }

Experimental peer executor for XLA/PJRT.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_xla::XlaExecutor;

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let module = XlaExecutor::default()
    .lower_compiled_to_stablehlo(&program)
    .unwrap();
assert!(module.as_str().contains("stablehlo.negate"));

Implementations

impl XlaExecutor

pub fn new(options: XlaExecutorOptions) -> Self

Create an executor with explicit options.

Examples

use tenferro_xla::{XlaExecutor, XlaExecutorOptions};

let executor = XlaExecutor::new(XlaExecutorOptions::default());
assert_eq!(executor.options(), XlaExecutorOptions::default());

pub fn from_env() -> Result<Self>

Create an executor by loading PJRT configuration from environment variables.

Examples

use tenferro_xla::XlaExecutor;

let _ = XlaExecutor::from_env();

Errors

Returns Error::MissingEnv when the configured plugin-path variable is unset, or Error::PluginLoad with the typed dynamic-library source when the path cannot be loaded.

pub fn from_env_var(var: &'static str) -> Result<Self>

Create an executor by loading a PJRT plugin path from a specific environment variable.

Examples

use tenferro_xla::XlaExecutor;

let _ = XlaExecutor::from_env_var("__TENFERRO_XLA_DOCS_UNSET");

Errors

Returns Error::MissingEnv when var is unset, or Error::PluginLoad with the typed dynamic-library source when its value cannot be loaded.

pub fn options(&self) -> XlaExecutorOptions

Return the executor options.

Examples

use tenferro_xla::XlaExecutor;

assert_eq!(XlaExecutor::default().options(), Default::default());

pub fn has_loaded_pjrt_plugin(&self) -> bool

Return whether this executor owns a loaded PJRT plugin.

Examples

use tenferro_xla::XlaExecutor;

assert!(!XlaExecutor::default().has_loaded_pjrt_plugin());

pub fn lower_to_stablehlo( &self, program: &SemanticProgram, ) -> Result<StableHloModule>

Lower a graph program to StableHLO without executing it.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_xla::XlaExecutor;

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let module = XlaExecutor::default().lower_to_stablehlo(program.program()).unwrap();
assert!(module.as_str().contains("stablehlo.negate"));

Errors

Returns Error::UnsupportedDType, Error::UnsupportedOp, or Error::NonStaticShape for unsupported graph content, and Error::InvalidProgram for inconsistent graph metadata.

pub fn lower_compiled_to_stablehlo( &self, program: &CompiledGraph, ) -> Result<StableHloModule>

Lower a compiled graph to StableHLO without executing it.

This is the preferred public lowering boundary for graph users. It consumes CompiledGraph directly and does not route through native Runtime execution staging.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_xla::XlaExecutor;

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let module = XlaExecutor::default()
    .lower_compiled_to_stablehlo(&program)
    .unwrap();
assert!(module.as_str().contains("stablehlo.negate"));

Errors

Returns Error::UnsupportedDType, Error::UnsupportedOp, or Error::NonStaticShape for unsupported graph content, and Error::InvalidProgram for inconsistent graph metadata.

pub fn run_many_with_inputs( &self, program: &SemanticProgram, inputs: &[&Tensor], ) -> Result<Vec<Tensor>>

Execute a graph program through a loaded PJRT plugin and return all outputs.

Inputs must match the ordered semantic-program input metadata exactly. This experimental execution path supports the same exact-static-shape, F32/F64 subset as StableHLO lowering.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_tensor::Tensor;
use tenferro_xla::{Error, XlaExecutor};

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let input = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let err = XlaExecutor::default()
    .run_many_with_inputs(program.program(), &[&input])
    .unwrap_err();
assert!(matches!(err, Error::PjrtFeatureDisabled | Error::PjrtPluginNotLoaded));

Errors

Returns Error::PjrtFeatureDisabled or Error::PjrtPluginNotLoaded when no PJRT executor is available, Error::InvalidProgram for input count/dtype/shape mismatches, and Error::PjrtCall for vendor status failures.

pub fn run_compiled_many_with_inputs( &self, program: &CompiledGraph, inputs: &[&Tensor], ) -> Result<Vec<Tensor>>

Execute a compiled graph through a loaded PJRT plugin and return all outputs.

This wrapper accepts the same CompiledGraph that native runtime execution consumes, while preserving the current XLA/PJRT exact-static F32/F64 subset. It delegates to the semantic-program PJRT executor and does not route through native Runtime execution.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_tensor::Tensor;
use tenferro_xla::{Error, XlaExecutor};

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let input = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let err = XlaExecutor::default()
    .run_compiled_many_with_inputs(&program, &[&input])
    .unwrap_err();
assert!(matches!(err, Error::PjrtFeatureDisabled | Error::PjrtPluginNotLoaded));

Errors

Returns Error::PjrtFeatureDisabled or Error::PjrtPluginNotLoaded when no PJRT executor is available, Error::InvalidProgram for input count/dtype/shape mismatches, and Error::PjrtCall for vendor status failures.

pub fn run_with_inputs( &self, program: &SemanticProgram, inputs: &[&Tensor], ) -> Result<Tensor>

Execute a single-output graph program through a loaded PJRT plugin.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_tensor::Tensor;
use tenferro_xla::{Error, XlaExecutor};

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let input = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let err = XlaExecutor::default().run_with_inputs(program.program(), &[&input]).unwrap_err();
assert!(matches!(err, Error::PjrtFeatureDisabled | Error::PjrtPluginNotLoaded));

Errors

Propagates the run_many_with_inputs errors and returns Error::InvalidProgram if the program does not have exactly one output.

pub fn run_compiled_with_inputs( &self, program: &CompiledGraph, inputs: &[&Tensor], ) -> Result<Tensor>

Execute a single-output compiled graph through a loaded PJRT plugin.

Examples

use tenferro_runtime::{GraphCompiler, TracedTensor};
use tenferro_tensor::Tensor;
use tenferro_xla::{Error, XlaExecutor};

let x = TracedTensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let mut compiler = GraphCompiler::new();
let y = x.neg().unwrap();
let program = compiler.compile(&y).unwrap();
let input = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let err = XlaExecutor::default()
    .run_compiled_with_inputs(&program, &[&input])
    .unwrap_err();
assert!(matches!(err, Error::PjrtFeatureDisabled | Error::PjrtPluginNotLoaded));

Errors

Propagates the run_compiled_many_with_inputs errors and returns Error::InvalidProgram if the program does not have exactly one output.

Trait Implementations

impl Debug for XlaExecutor

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

Formats the value using the given formatter.

impl Default for XlaExecutor

fn default() -> Self

Returns the “default value” for a type.