Struct CpuBackend 

pub struct CpuBackend { /* private fields */ }

CPU execution backend.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::new();

Implementations

impl CpuBackend

pub fn new() -> CpuBackend

Create a CPU backend using the environment-driven CPU context.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::new();

pub fn try_new() -> Result<CpuBackend, Error>

Try to create a CPU backend using RAYON_NUM_THREADS.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::try_new().unwrap();
let _ = backend.num_threads();

pub fn from_context(ctx: Arc<CpuContext>) -> CpuBackend

Create a CPU backend from an existing context.

Examples

use std::sync::Arc;
use tenferro_tensor::cpu::{CpuBackend, CpuContext};

let ctx = Arc::new(CpuContext::with_threads(2));
let backend = CpuBackend::from_context(ctx);
assert_eq!(backend.num_threads(), 2);

pub fn with_threads(num_threads: usize) -> CpuBackend

Create a CPU backend with a custom thread count.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::with_threads(2);
assert_eq!(backend.num_threads(), 2);

pub fn num_threads(&self) -> usize

Return the number of threads in this backend’s CPU context.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::with_threads(2);
assert_eq!(backend.num_threads(), 2);

pub fn buffer_pool_len(&self) -> usize

Number of retained typed host buffers currently held by this backend.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::new();
assert_eq!(backend.buffer_pool_len(), 0);

pub fn install<R>(&self, op: impl FnOnce() -> R + Send) -> R

where R: Send,

Run a closure inside this backend’s shared rayon thread pool.

Examples

use tenferro_tensor::cpu::CpuBackend;

let backend = CpuBackend::with_threads(1);
let value = backend.install(|| 1 + 1);
assert_eq!(value, 2);

Trait Implementations

impl Default for CpuBackend

fn default() -> CpuBackend

Returns the “default value” for a type.

impl<Alg> SemiringBackend<Alg> for CpuBackend

where Alg: Semiring,

fn batched_gemm( &mut self, lhs: &TypedTensor<<Alg as Algebra>::Scalar>, rhs: &TypedTensor<<Alg as Algebra>::Scalar>, config: &DotGeneralConfig, ) -> Result<TypedTensor<<Alg as Algebra>::Scalar>, Error>

fn add( &mut self, lhs: &TypedTensor<<Alg as Algebra>::Scalar>, rhs: &TypedTensor<<Alg as Algebra>::Scalar>, ) -> Result<TypedTensor<<Alg as Algebra>::Scalar>, Error>

fn mul( &mut self, lhs: &TypedTensor<<Alg as Algebra>::Scalar>, rhs: &TypedTensor<<Alg as Algebra>::Scalar>, ) -> Result<TypedTensor<<Alg as Algebra>::Scalar>, Error>

fn reduce_sum( &mut self, input: &TypedTensor<<Alg as Algebra>::Scalar>, axes: &[usize], ) -> Result<TypedTensor<<Alg as Algebra>::Scalar>, Error>

impl TensorBackend for CpuBackend

fn add(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn mul(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn neg(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn conj(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn div(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn abs(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn sign(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn maximum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn minimum(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn compare( &mut self, lhs: &Tensor, rhs: &Tensor, dir: &CompareDir, ) -> Result<Tensor, Error>

fn select( &mut self, pred: &Tensor, on_true: &Tensor, on_false: &Tensor, ) -> Result<Tensor, Error>

fn clamp( &mut self, input: &Tensor, lower: &Tensor, upper: &Tensor, ) -> Result<Tensor, Error>

fn exp(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn log(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn sin(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn cos(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn tanh(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn sqrt(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn rsqrt(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn pow(&mut self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, Error>

fn expm1(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn log1p(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn transpose(&mut self, input: &Tensor, perm: &[usize]) -> Result<Tensor, Error>

fn reshape(&mut self, input: &Tensor, shape: &[usize]) -> Result<Tensor, Error>

fn broadcast_in_dim( &mut self, input: &Tensor, shape: &[usize], dims: &[usize], ) -> Result<Tensor, Error>

fn convert(&mut self, input: &Tensor, to: DType) -> Result<Tensor, Error>

fn extract_diagonal( &mut self, input: &Tensor, axis_a: usize, axis_b: usize, ) -> Result<Tensor, Error>

fn embed_diagonal( &mut self, input: &Tensor, axis_a: usize, axis_b: usize, ) -> Result<Tensor, Error>

fn tril(&mut self, input: &Tensor, k: i64) -> Result<Tensor, Error>

fn triu(&mut self, input: &Tensor, k: i64) -> Result<Tensor, Error>

fn reduce_sum( &mut self, input: &Tensor, axes: &[usize], ) -> Result<Tensor, Error>

fn reduce_prod( &mut self, input: &Tensor, axes: &[usize], ) -> Result<Tensor, Error>

fn reduce_max( &mut self, input: &Tensor, axes: &[usize], ) -> Result<Tensor, Error>

fn reduce_min( &mut self, input: &Tensor, axes: &[usize], ) -> Result<Tensor, Error>

fn dot_general( &mut self, lhs: &Tensor, rhs: &Tensor, config: &DotGeneralConfig, ) -> Result<Tensor, Error>

fn gather( &mut self, operand: &Tensor, start_indices: &Tensor, config: &GatherConfig, ) -> Result<Tensor, Error>

fn scatter( &mut self, operand: &Tensor, scatter_indices: &Tensor, updates: &Tensor, config: &ScatterConfig, ) -> Result<Tensor, Error>

fn slice( &mut self, input: &Tensor, config: &SliceConfig, ) -> Result<Tensor, Error>

fn dynamic_slice( &mut self, input: &Tensor, starts: &Tensor, slice_sizes: &[usize], ) -> Result<Tensor, Error>

fn pad(&mut self, input: &Tensor, config: &PadConfig) -> Result<Tensor, Error>

fn concatenate( &mut self, inputs: &[&Tensor], axis: usize, ) -> Result<Tensor, Error>

fn reverse(&mut self, input: &Tensor, axes: &[usize]) -> Result<Tensor, Error>

fn cholesky(&mut self, input: &Tensor) -> Result<Tensor, Error>

fn triangular_solve( &mut self, a: &Tensor, b: &Tensor, left_side: bool, lower: bool, transpose_a: bool, unit_diagonal: bool, ) -> Result<Tensor, Error>

fn lu(&mut self, input: &Tensor) -> Result<Vec<Tensor>, Error>

fn svd(&mut self, input: &Tensor) -> Result<Vec<Tensor>, Error>

fn qr(&mut self, input: &Tensor) -> Result<Vec<Tensor>, Error>

fn eigh(&mut self, input: &Tensor) -> Result<Vec<Tensor>, Error>

fn eig(&mut self, input: &Tensor) -> Result<Vec<Tensor>, Error>

fn solve(&mut self, a: &Tensor, b: &Tensor) -> Result<Tensor, Error>

fn with_exec_session<R>( &mut self, f: impl FnOnce(&mut dyn TensorExec) -> R + Send, ) -> R

where R: Send,

Execute a batch of operations inside the backend’s execution context.

fn reclaim_buffer(&mut self, tensor: Tensor)

Reclaim a tensor buffer for backend-specific reuse.

fn download_to_host(&mut self, tensor: &Tensor) -> Result<Tensor, Error>

Materialize a backend tensor into host memory.

fn upload_host_tensor(&mut self, tensor: &Tensor) -> Result<Tensor, Error>

Upload a host tensor into backend-owned storage when needed.