Struct CpuBackend 

pub struct CpuBackend;

CPU backend using strided-kernel and GEMM.

Dispatched automatically when tensors reside on LogicalMemorySpace::MainMemory. Implements the semiring core and semiring fast-path families for Standard<T>.

Examples

use tenferro_algebra::Standard;
use tenferro_device::LogicalMemorySpace;
use tenferro_prims::{CpuBackend, CpuContext, SemiringCoreDescriptor, TensorSemiringCore};
use tenferro_tensor::{MemoryOrder, Tensor};

let mut ctx = CpuContext::try_new(4).unwrap();
let col = MemoryOrder::ColumnMajor;
let mem = LogicalMemorySpace::MainMemory;
let a_base = Tensor::<f64>::zeros(&[3, 4], mem, col).unwrap();
let a = a_base.permute(&[1, 0]).unwrap();
let mut b = Tensor::<f64>::zeros(&[4, 3], mem, col).unwrap();
let plan = <CpuBackend as TensorSemiringCore<Standard<f64>>>::plan(
    &mut ctx,
    &SemiringCoreDescriptor::MakeContiguous,
    &[&[4, 3], &[4, 3]],
)
.unwrap();
<CpuBackend as TensorSemiringCore<Standard<f64>>>::execute(
    &mut ctx,
    &plan,
    1.0,
    &[&a],
    0.0,
    &mut b,
)
.unwrap();

Implementations

impl CpuBackend

pub fn resolve_conj<T: Scalar + Conjugate>( _ctx: &mut CpuContext, src: &Tensor<T>, ) -> Tensor<T>

Materialize a lazily-conjugated tensor.

If src.is_conjugated() is false, returns a shallow clone. If true, routes through the tensor-layer logical combine substrate so the result is resolved (conjugated = false) without reimplementing the copy logic here.

Examples

use tenferro_prims::{CpuBackend, CpuContext};

let mut ctx = CpuContext::try_new(1).unwrap();
let a_conj = a.into_conj(); // lazy
let a_resolved = CpuBackend::resolve_conj(&mut ctx, &a_conj);
assert!(!a_resolved.is_conjugated());

Trait Implementations

impl<S: Scalar + 'static> TensorAnalyticPrims<Standard<S>> for CpuBackend

type Plan = CpuAnalyticPlan

type Context = CpuContext

fn plan( _ctx: &mut Self::Context, desc: &AnalyticPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan an analytic-family operation for the given input/output shapes.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, alpha: S, inputs: &[&Tensor<S>], beta: S, output: &mut Tensor<S>, ) -> Result<()>

Execute a previously planned analytic-family operation.

fn has_analytic_support(desc: AnalyticPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<Input> TensorComplexRealPrims<Input> for CpuBackend

where Input: ComplexFloat + Scalar + 'static, Input::Real: CpuScalarValue + Float,

type Real = <Input as ComplexFloat>::Real

The real-valued output scalar type.

type Plan = CpuComplexRealPlan

Backend plan type.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &ComplexRealPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a complex-to-real unary operation for the given input/output shapes.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, alpha: Input::Real, inputs: &[&Tensor<Input>], beta: Input::Real, output: &mut Tensor<Self::Real>, ) -> Result<()>

Execute a previously planned complex-to-real unary operation.

fn has_complex_real_support(desc: ComplexRealPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<Input> TensorComplexScalePrims<Input> for CpuBackend

where Input: ComplexFloat + Scalar + 'static + Add<Output = Input> + Mul<Input::Real, Output = Input> + Mul<Output = Input>, Input::Real: Scalar + Send + Sync,

type Plan = CpuComplexScalePlan

Backend plan type.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &ComplexScalePrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a complex-by-real pointwise operation for the given shapes.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, alpha: Input, lhs: &Tensor<Input>, rhs: &Tensor<Input::Real>, beta: Input, output: &mut Tensor<Input>, ) -> Result<()>

Execute a previously planned complex-by-real pointwise operation.

fn has_complex_scale_support(desc: ComplexScalePrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<S: Scalar + 'static> TensorIndexingPrims<Standard<S>> for CpuBackend

type Plan = CpuIndexingPlan

Backend-specific execution plan.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &IndexingPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan an indexing operation for the given input/index/output shapes.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, inputs: &[&Tensor<S>], indices: &Tensor<i64>, output: &mut Tensor<S>, ) -> Result<()>

Execute a previously planned indexing operation.

fn has_indexing_support(_desc: IndexingPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<S> TensorMetadataCastPrims<S> for CpuBackend

where S: Scalar + NumCast + 'static,

type Plan = MetadataCastPrimsDescriptor

Backend plan type.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &MetadataCastPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a metadata-to-scalar bridge operation.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, alpha: S, inputs: &[MetadataScalarTensorRef<'_, S>], beta: S, output: &mut Tensor<S>, ) -> Result<()>

Execute a previously planned metadata-to-scalar bridge operation.

fn has_metadata_cast_support(desc: MetadataCastPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl TensorMetadataPrims for CpuBackend

type Plan = MetadataPrimsDescriptor

Backend plan type.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &MetadataPrimsDescriptor, inputs: &[MetadataTensorRef<'_>], output: MetadataTensorMut<'_>, ) -> Result<Self::Plan>

Plan a metadata-family operation for the given input and output tensor handles.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, inputs: &[MetadataTensorRef<'_>], output: MetadataTensorMut<'_>, ) -> Result<()>

Execute a previously planned metadata-family operation in overwrite mode.

fn has_metadata_support(desc: MetadataPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl TensorRngPrims<Standard<f64>> for CpuBackend

type Plan = (RngPrimsDescriptor, Vec<usize>)

Backend-specific execution plan.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &RngPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a tensor RNG operation for the given output shape.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, generator: &mut Generator, output: &mut Tensor<f64>, ) -> Result<()>

Execute a previously planned RNG operation.

fn has_rng_support(desc: RngPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl TensorRngPrims<Standard<i32>> for CpuBackend

type Plan = (RngPrimsDescriptor, Vec<usize>)

Backend-specific execution plan.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &RngPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a tensor RNG operation for the given output shape.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, generator: &mut Generator, output: &mut Tensor<i32>, ) -> Result<()>

Execute a previously planned RNG operation.

fn has_rng_support(desc: RngPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<S: Scalar + 'static> TensorScalarPrims<Standard<S>> for CpuBackend

type Plan = CpuScalarPlan

type Context = CpuContext

fn plan( _ctx: &mut Self::Context, desc: &ScalarPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a scalar-family operation for the given input/output shapes.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, alpha: S, inputs: &[&Tensor<S>], beta: S, output: &mut Tensor<S>, ) -> Result<()>

Execute a previously planned scalar-family operation.

fn has_scalar_support(desc: ScalarPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.

impl<S: Scalar> TensorSemiringCore<Standard<S>> for CpuBackend

type Plan = CpuPlan<S>

Backend-specific plan type.

type Context = CpuContext

Backend-specific execution context.

fn plan( ctx: &mut CpuContext, desc: &SemiringCoreDescriptor, shapes: &[&[usize]], ) -> Result<CpuPlan<S>>

Plan a semiring-core operation.

fn execute( ctx: &mut CpuContext, plan: &CpuPlan<S>, alpha: S, inputs: &[&Tensor<S>], beta: S, output: &mut Tensor<S>, ) -> Result<()>

Execute a semiring-core operation.

impl<S: Scalar> TensorSemiringFastPath<Standard<S>> for CpuBackend

type Plan = CpuPlan<S>

Backend-specific plan type.

type Context = CpuContext

Backend-specific execution context.

fn plan( ctx: &mut CpuContext, desc: &SemiringFastPathDescriptor, shapes: &[&[usize]], ) -> Result<CpuPlan<S>>

Plan an optional semiring fast path.

fn execute( ctx: &mut CpuContext, plan: &CpuPlan<S>, alpha: S, inputs: &[&Tensor<S>], beta: S, output: &mut Tensor<S>, ) -> Result<()>

Execute an optional semiring fast path.

fn has_fast_path(desc: SemiringFastPathDescriptor) -> bool

Query whether the optional path is available.

impl<S: Scalar + PartialOrd + 'static> TensorSortPrims<Standard<S>> for CpuBackend

type Plan = CpuSortPlan

Backend-specific execution plan.

type Context = CpuContext

Backend execution context.

fn plan( _ctx: &mut Self::Context, desc: &SortPrimsDescriptor, shapes: &[&[usize]], ) -> Result<Self::Plan>

Plan a sort operation for the given input shape.

fn execute( _ctx: &mut Self::Context, plan: &Self::Plan, input: &Tensor<S>, values_out: &mut Tensor<S>, indices_out: &mut Tensor<i64>, ) -> Result<()>

Execute a previously planned sort operation.

fn has_sort_support(_desc: &SortPrimsDescriptor) -> bool

Report whether the backend advertises support for the given descriptor.