Struct CpuBackend 

pub struct CpuBackend { /* private fields */ }

CPU execution backend.

Examples

use tenferro_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_cpu::CpuBackend;

let backend = CpuBackend::new();

pub fn with_kind(kind: CpuBackendKind) -> Result<Self>

Create a CPU backend using the selected compiled provider.

Examples

use tenferro_cpu::{CpuBackend, CpuBackendKind};

let backend = CpuBackend::with_kind(CpuBackendKind::default_compiled()).unwrap();
assert_eq!(backend.kind(), CpuBackendKind::default_compiled());

pub fn try_new() -> Result<Self>

Try to create a CPU backend using RAYON_NUM_THREADS.

Examples

use tenferro_cpu::CpuBackend;

let backend = CpuBackend::try_new()
    .unwrap_or_else(|_| CpuBackend::with_threads(1).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_cpu::{CpuBackend, CpuContext};

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

pub fn from_context_with_buffer_pool_limit( ctx: Arc<CpuContext>, max_retained_capacity_bytes: usize, ) -> Self

Create a CPU backend from an existing context and buffer-pool retention cap.

The cap is measured in retained vector capacity bytes. A cap of zero disables buffer retention.

Examples

use std::sync::Arc;
use tenferro_cpu::{CpuBackend, CpuContext};

let ctx = Arc::new(CpuContext::with_threads(1).unwrap());
let backend = CpuBackend::from_context_with_buffer_pool_limit(ctx, 0);
assert_eq!(backend.buffer_pool_limit_bytes(), 0);

pub fn with_threads(num_threads: usize) -> Result<Self>

Create a CPU backend with a custom thread count.

Examples

use tenferro_cpu::CpuBackend;

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

Errors

Returns an error when num_threads is zero or Rayon rejects the pool.

pub fn with_threads_and_kind( num_threads: usize, kind: CpuBackendKind, ) -> Result<Self>

Create a CPU backend with a custom thread count and provider.

Examples

use tenferro_cpu::{CpuBackend, CpuBackendKind};

let backend = CpuBackend::with_threads_and_kind(
    1,
    CpuBackendKind::default_compiled(),
)?;
assert_eq!(backend.num_threads(), 1);

Errors

Returns an error when num_threads is zero, Rayon rejects the pool, or the selected provider is unavailable.

pub fn kind(&self) -> CpuBackendKind

Return the runtime CPU provider selected by this backend.

Examples

use tenferro_cpu::{CpuBackend, CpuBackendKind};

let backend = CpuBackend::new();
assert_eq!(backend.kind(), CpuBackendKind::default_compiled());

pub fn num_threads(&self) -> usize

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

Examples

use tenferro_cpu::CpuBackend;

let backend = CpuBackend::with_threads(2).unwrap();
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_cpu::CpuBackend;

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

pub fn buffer_pool_stats(&self) -> BufferPoolStats

Snapshot reusable typed host buffers currently retained by this backend.

Examples

use tenferro_cpu::CpuBackend;

let backend = CpuBackend::new();
let stats = backend.buffer_pool_stats();
assert_eq!(stats.buffers, 0);
assert_eq!(stats.capacity_bytes, 0);

pub fn buffer_pool_cache_stats(&self) -> CacheStats

Return cache-style stats for the CPU buffer pool.

Examples

use tenferro_cpu::CpuBackend;

let backend = CpuBackend::new();
let stats = backend.buffer_pool_cache_stats();
assert_eq!(stats.entries, 0);
assert_eq!(stats.retained_bytes, 0);

pub fn buffer_pool_limit_bytes(&self) -> usize

Current CPU buffer-pool retention limit in bytes.

Examples

use std::sync::Arc;
use tenferro_cpu::{CpuBackend, CpuContext};

let backend = CpuBackend::from_context_with_buffer_pool_limit(
    Arc::new(CpuContext::with_threads(1).unwrap()),
    4096,
);
assert_eq!(backend.buffer_pool_limit_bytes(), 4096);

pub fn set_buffer_pool_limit_bytes( &mut self, max_retained_capacity_bytes: usize, )

Update the CPU buffer-pool retention limit in bytes.

Shrinking the limit evicts retained buffers immediately. A limit of zero disables buffer retention.

Examples

use tenferro_cpu::CpuBackend;

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

pub fn reset_buffer_pool(&mut self)

Reset reusable typed host buffers currently retained by this backend.

This releases pool-owned vectors to the process allocator. Operating system RSS may not fall immediately because allocators can retain freed pages for future allocations.

Examples

use tenferro_cpu::CpuBackend;

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

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

Run a closure in this backend’s CPU execution scope.

Examples

use tenferro_cpu::CpuBackend;

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

Trait Implementations

impl BackendSessionHost for CpuBackend

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

impl Debug for CpuBackend

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

Formats the value using the given formatter.

impl Default for CpuBackend

fn default() -> Self

Returns the “default value” for a type.

impl TensorAnalytic for CpuBackend

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

fn exp_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn log_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn sin_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn cos_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn tanh_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn sqrt_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn rsqrt_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn pow_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

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

fn expm1_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn log1p_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

impl TensorBuffer for CpuBackend

fn reclaim_buffer(&mut self, tensor: Tensor)

impl TensorDeviceTransfer for CpuBackend

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

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

impl TensorDot for CpuBackend

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

impl TensorElementwise for CpuBackend

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

fn add_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

Elementwise addition accepting either owned tensors or borrowed views.

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

fn mul_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

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

fn neg_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn conj_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn div_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

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

fn abs_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn sign_read(&mut self, input: TensorRead<'_>) -> Result<Tensor>

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

fn maximum_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

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

fn minimum_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, ) -> Result<Tensor>

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

fn compare_read( &mut self, lhs: TensorRead<'_>, rhs: TensorRead<'_>, dir: &CompareDir, ) -> Result<Tensor>

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

fn select_read( &mut self, pred: TensorRead<'_>, on_true: TensorRead<'_>, on_false: TensorRead<'_>, ) -> Result<Tensor>

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

fn clamp_read( &mut self, input: TensorRead<'_>, lower: TensorRead<'_>, upper: TensorRead<'_>, ) -> Result<Tensor>

impl TensorIndexing for CpuBackend

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 dynamic_update_slice( &mut self, operand: &Tensor, update: &Tensor, starts: &Tensor, ) -> 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>

impl TensorReduction for CpuBackend

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

fn reduce_sum_read( &mut self, input: TensorRead<'_>, axes: &[usize], ) -> Result<Tensor>

Sum elements across axes from an owned tensor or borrowed view.

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

fn reduce_prod_read( &mut self, input: TensorRead<'_>, axes: &[usize], ) -> Result<Tensor>

Multiply elements across axes from an owned tensor or borrowed view.

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

fn reduce_max_read( &mut self, input: TensorRead<'_>, axes: &[usize], ) -> Result<Tensor>

Take maximum values across axes from an owned tensor or borrowed view.

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

fn reduce_min_read( &mut self, input: TensorRead<'_>, axes: &[usize], ) -> Result<Tensor>

Take minimum values across axes from an owned tensor or borrowed view.

impl TensorStructural for CpuBackend

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

fn transpose_read( &mut self, input: TensorRead<'_>, perm: &[usize], ) -> Result<Tensor>

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

fn reshape_read( &mut self, input: TensorRead<'_>, shape: &[usize], ) -> Result<Tensor>

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

fn broadcast_in_dim_read( &mut self, input: TensorRead<'_>, shape: &[usize], dims: &[usize], ) -> Result<Tensor>

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

Cast a tensor to another dtype using explicit dtype projection.

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 convert(&mut self, input: &Tensor, to: DType) -> Result<Tensor, Error>

Convert a tensor to another dtype using checked dtype conversion.

impl<T, R> TensorViewCanonicalization<T, R> for CpuBackend

where T: Clone + 'static, R: TensorRank,

fn to_contiguous( &mut self, view: &TypedTensorView<'_, T, R>, ) -> Result<TypedTensor<T, R>>

fn copy_from_contiguous( &mut self, src: &TypedTensor<T, R>, dst: &mut TypedTensorViewMut<'_, T, R>, ) -> Result<()>

impl BackendCachedDot for CpuBackend

impl BackendRuntimeCache for CpuBackend

impl TensorBackend for CpuBackend

impl TensorFusion for CpuBackend