Struct CpuContext 

pub struct CpuContext { /* private fields */ }

CPU execution context.

Encapsulates CPU-side execution resources, analogous to cuTENSOR’s cutensorHandle_t. Holds a rayon thread pool, a PlanCache for plan reuse, and reusable temporary buffers for host-side execution helpers.

Examples

use tenferro_prims::CpuContext;

let mut ctx = CpuContext::try_new(4)?; // 4-thread pool
assert_eq!(ctx.num_threads(), 4);

Implementations

impl CpuContext

pub fn default_num_threads() -> usize

Return the backend-defined default CPU thread count.

On Linux this prefers the current process CPU affinity mask. Other platforms fall back to std::thread::available_parallelism.

pub fn try_new(num_threads: usize) -> Result<CpuContext, Error>

Create a new CPU context with the given number of threads.

Errors

Returns tenferro_device::Error::InvalidArgument when num_threads == 0, or tenferro_device::Error::DeviceError when the underlying Rayon thread-pool construction fails.

Examples

use tenferro_prims::CpuContext;

let ctx = CpuContext::try_new(2)?;
assert_eq!(ctx.num_threads(), 2);

pub fn try_new_default() -> Result<CpuContext, Error>

Create a new CPU context using the backend-defined default thread count.

pub fn new(num_threads: usize) -> CpuContext

Create a new CPU context with the given number of threads.

This is a convenience wrapper around CpuContext::try_new. Production code should generally prefer the fallible constructor so context setup errors stay in the normal Result flow.

Panics

Panics if CpuContext::try_new returns an error.

Examples

use tenferro_prims::CpuContext;

let ctx = CpuContext::new(1);
assert_eq!(ctx.num_threads(), 1);

pub fn new_default() -> CpuContext

Create a new CPU context using the backend-defined default thread count.

pub fn num_threads(&self) -> usize

Returns the number of threads in the pool.

pub fn thread_pool(&self) -> &ThreadPool

Returns a reference to the underlying rayon thread pool.

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

where R: Send,

Run a closure inside the owned rayon thread pool.

pub fn plan_cache_mut(&mut self) -> &mut PlanCache

Returns a mutable reference to the plan cache.

Trait Implementations

impl Default for CpuContext

fn default() -> CpuContext

Returns the “default value” for a type.

impl<Input> TensorComplexRealContextFor<Input> for CpuContext

where Input: Scalar + ComplexFloat, <Input as ComplexFloat>::Real: Scalar, CpuBackend: TensorComplexRealPrims<Input, Context = CpuContext, Real = <Input as ComplexFloat>::Real>,

type ComplexRealBackend = CpuBackend

Backend associated with this context for the complex-to-real family.

impl<Input> TensorComplexScaleContextFor<Input> for CpuContext

where Input: ComplexFloat + Scalar, <Input as ComplexFloat>::Real: Scalar + Send + Sync, CpuBackend: TensorComplexScalePrims<Input, Context = CpuContext>,

type ComplexScaleBackend = CpuBackend

Backend associated with the complex-by-real family.

impl<Alg> TensorIndexingContextFor<Alg> for CpuContext

where Alg: Algebra, CpuBackend: TensorIndexingPrims<Alg, Context = CpuContext>,

type IndexingBackend = CpuBackend

Backend associated with this context for the indexing family.

impl<T> TensorLinalgContextFor<T> for CpuContext

where T: KernelLinalgScalar,

type Backend = CpuTensorLinalgBackend

The backend associated with this context type.

impl TensorMetadataContextFor for CpuContext

where CpuBackend: TensorMetadataPrims<Context = CpuContext>,

type MetadataBackend = CpuBackend

Backend associated with this context for the metadata family.

impl<T> TensorResolveConjContextFor<T> for CpuContext

where T: Scalar + Conjugate,

fn resolve_conj(ctx: &mut CpuContext, src: &Tensor<T>) -> Tensor<T>

Materialize a lazily-conjugated tensor using the backend tied to Self.

impl<Alg> TensorScalarContextFor<Alg> for CpuContext

where Alg: Algebra, CpuBackend: TensorScalarPrims<Alg, Context = CpuContext>,

type ScalarBackend = CpuBackend

Backend associated with this context for the scalar family.

impl<Alg> TensorSemiringContextFor<Alg> for CpuContext

where Alg: Semiring, CpuBackend: TensorSemiringCore<Alg, Context = CpuContext>,

type SemiringBackend = CpuBackend

Backend associated with this context for the given algebra family.

impl<Alg> TensorSortContextFor<Alg> for CpuContext

where Alg: Algebra, <Alg as Algebra>::Scalar: PartialOrd, CpuBackend: TensorSortPrims<Alg, Context = CpuContext>,

type SortBackend = CpuBackend

Backend associated with this context for the sort family.