Struct CpuExecutionContext 

pub struct CpuExecutionContext<'a> { /* private fields */ }

Borrowed execution policy for an already-entered CPU operation.

The context exposes immutable domain facts while keeping the resource lease, executor object, and the checked executor-entry boundary private. Providers cannot install or submit work through this value.

Examples

Providers inspect this value inside a trait method:

use tenferro_cpu::provider::CpuExecutionContext;
assert!(context.thread_budget().get() >= 1);

Implementations

impl<'a> CpuExecutionContext<'a>

pub fn batch_policy(&self) -> CpuBatchPolicy

The effective batch policy for batched work in this context.

It is the backend default unless a session scope overrides it; see crate::with_batch_policy.

Examples

use tenferro_cpu::{with_cpu_exec_session, CpuBackend, CpuBatchStrategy};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::with_threads(1)?;
let strategy = backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |cpu| {
        cpu.with_linalg_pool(|context, _| Ok(context.batch_policy().strategy()))
    })
    .expect("a CPU backend session")
})??;
assert_eq!(strategy, CpuBatchStrategy::Auto);

pub fn can_fan_out_lanes(&self) -> bool

Whether Self::with_outer_lanes can fan out from this context.

Examples

use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::with_threads(1)?;
let fans_out = backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |cpu| {
        cpu.with_linalg_pool(|context, _| Ok(context.can_fan_out_lanes()))
    })
    .expect("a CPU backend session")
})??;
assert!(!fans_out);

pub fn is_outer_fan_out_lane(&self) -> bool

Whether this context is one lane of tenferro’s own outer fan-out.

Such a lane runs concurrently with its siblings. Its mode is ParallelMode::Sequential, so it may not start inner parallel work, and a provider whose declared parallelism is an independent runtime (the default for external BLAS/LAPACK) is rejected before dispatch. Running on a Rayon worker is not by itself outer fan-out.

Examples

use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::with_threads(1)?;
let lane = backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |cpu| {
        cpu.with_linalg_pool(|context, _| Ok(context.is_outer_fan_out_lane()))
    })
    .expect("a CPU backend session")
})??;
assert!(!lane);

pub fn with_outer_lanes<I>( &self, jobs: I, job: impl Fn(I::Item, &CpuExecutionContext<'a>) + Sync, )

where I: IntoIterator, I::IntoIter: Send, I::Item: Send,

Run independent lane jobs as tenferro-owned outer fan-out inside this already-entered context’s own Rayon region.

Each item of jobs (typically one disjoint chunk of a batch) runs once and receives a lane context: Self::is_outer_fan_out_lane is true and the mode is ParallelMode::Sequential, so the lane neither starts inner parallel work nor reaches an independent-runtime provider. Fan-out needs an ParallelMode::Inner context of a Rayon executor with more than one thread; otherwise the jobs run in order on the calling thread, still with a lane context. No second pool is created: jobs run on the Rayon pool this context was entered in.

Examples

use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::with_threads(2)?;
let mut data = vec![1.0_f64; 8];
backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |cpu| {
        cpu.with_linalg_pool(|context, _| {
            context.with_outer_lanes(data.chunks_mut(3), |chunk, lane| {
                assert!(lane.is_outer_fan_out_lane());
                chunk.iter_mut().for_each(|value| *value *= 2.0);
            });
            Ok(())
        })
    })
    .expect("a CPU backend session")
})??;
assert_eq!(data, [2.0; 8]);

pub fn domain_id(&self) -> CpuDomainId

Return the stable identity of the selected CPU resource domain.

Examples

use tenferro_cpu::CpuExecutionContext;
let _domain_id = context.domain_id();

pub fn cpus(&self) -> Option<&CpuSet>

Return the selected domain’s declared logical CPU set, when present.

Examples

use tenferro_cpu::CpuExecutionContext;
if let Some(cpus) = context.cpus() {
    assert!(!cpus.is_empty());
}

pub fn admission_mode(&self) -> CpuAdmissionMode

Return the selected domain’s admission contract.

Examples

use tenferro_cpu::{CpuAdmissionMode, CpuExecutionContext};
let _mode: CpuAdmissionMode = context.admission_mode();

pub fn thread_budget(&self) -> NonZeroUsize

Return the non-zero maximum participating-thread budget.

Examples

use tenferro_cpu::CpuExecutionContext;
assert!(context.thread_budget().get() >= 1);

pub fn parallel_mode(&self) -> ParallelMode

Return the engine-selected scheduling mode for this entered provider call.

Provider calls observe Sequential or Inner. Outer scheduling creates a separate Sequential context inside every submitted child.

Examples

use tenferro_cpu::{CpuExecutionContext, ParallelMode};
assert!(matches!(
    context.parallel_mode(),
    ParallelMode::Sequential | ParallelMode::Inner
));

pub fn rayon_pool(&self) -> Option<&'a ThreadPool>

The Rayon pool this context’s inner parallel region runs on.

Some exactly when the context owns an inner region: parallel mode ParallelMode::Inner, a Rayon-backed executor, and a thread budget above one (the same gate as the faer policy). The caller is already on a worker of this pool, so work installed or scoped on it runs in place. A provider running its own kernels on the pool must use at most CpuExecutionContext::thread_budget threads, which can be smaller than the pool, and declares crate::CpuThreadCountControl::PerCallUpperBound with crate::CpuPlacementControl::EngineWorkers.

Examples

use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_tensor::BackendSessionHost;
let mut backend = CpuBackend::with_threads(2)?;
let workers = backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |cpu| {
        cpu.with_linalg_pool(|context, _| {
            Ok(context.rayon_pool().map(|pool| pool.current_num_threads()))
        })
    })
    .expect("a CPU backend session")
})??;
assert_eq!(workers, Some(2));

Trait Implementations

impl<'a> Clone for CpuExecutionContext<'a>

fn clone(&self) -> CpuExecutionContext<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for CpuExecutionContext<'a>

impl Debug for CpuExecutionContext<'_>

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

Formats the value using the given formatter.