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() -> Self

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<Self>

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>) -> Self

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) -> Self

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() -> Self

Returns the “default value” for a type.

impl<Alg: Semiring> SemiringBackend<Alg> for CpuBackend

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

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

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

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

impl TensorBackend for CpuBackend

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

Materialize a backend tensor into host memory.

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

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