use crate::exec::policy::{ExecutionPolicy, FallbackPolicy, GradMode, MathMode};
use crate::tensor::backend::StorageBackend;
#[derive(Debug, Clone)]
pub struct ExecutionContext<B: StorageBackend> {
pub backend: B,
pub policy: ExecutionPolicy,
}
impl<B: StorageBackend> ExecutionContext<B> {
#[must_use]
pub const fn new(backend: B) -> Self {
Self {
backend,
policy: ExecutionPolicy::new(),
}
}
#[must_use]
pub const fn with_policy(backend: B, policy: ExecutionPolicy) -> Self {
Self { backend, policy }
}
#[cfg(feature = "std")]
#[must_use]
pub fn from_scope(backend: B) -> Self {
Self {
backend,
policy: ExecutionPolicy::current(),
}
}
#[cfg(not(feature = "std"))]
#[must_use]
pub const fn from_scope(backend: B) -> Self {
Self::new(backend)
}
#[must_use]
pub const fn backend(&self) -> &B {
&self.backend
}
#[must_use]
pub fn backend_mut(&mut self) -> &mut B {
&mut self.backend
}
#[must_use]
pub fn into_backend(self) -> B {
self.backend
}
#[must_use]
pub const fn policy(&self) -> ExecutionPolicy {
self.policy
}
#[must_use]
pub const fn math_mode(&self) -> MathMode {
self.policy.math_mode
}
#[must_use]
pub const fn fallback(&self) -> FallbackPolicy {
self.policy.fallback
}
#[must_use]
pub const fn grad_mode(&self) -> GradMode {
self.policy.grad_mode
}
#[must_use]
pub const fn training(&self) -> bool {
self.policy.training
}
#[must_use]
pub const fn with_math_mode(mut self, math_mode: MathMode) -> Self {
self.policy.math_mode = math_mode;
self
}
#[must_use]
pub const fn with_fallback(mut self, fallback: FallbackPolicy) -> Self {
self.policy.fallback = fallback;
self
}
#[must_use]
pub const fn with_grad_mode(mut self, grad_mode: GradMode) -> Self {
self.policy.grad_mode = grad_mode;
self
}
#[must_use]
pub const fn with_training(mut self, training: bool) -> Self {
self.policy.training = training;
self
}
#[must_use]
pub const fn precision_policy(&self) -> crate::exec::RuntimePrecisionPolicy {
self.policy.precision
}
#[must_use]
pub const fn with_precision_policy(
mut self,
precision: crate::exec::RuntimePrecisionPolicy,
) -> Self {
self.policy.precision = precision;
self
}
}