use cpueinsum::tcontract::api::{DType, Problem};
use cpueinsum::tcontract::{Algorithm, PlanConfig, SliceAccumulationSource};
use cpueinsum::Exec;
use cpueinsum_blas::{BlasError, BlasScalar, ExecutionRoute};
#[allow(clippy::large_enum_variant)]
#[derive(Debug)]
pub(crate) enum BinaryPlan<T: BlasScalar> {
Native(cpueinsum::BinaryPlan<T>),
Vendor(cpueinsum_blas::BinaryPlan<T>),
}
const THIN_ROW_ROLE: usize = 2;
impl<T: BlasScalar> BinaryPlan<T> {
pub(crate) fn new(problem: &Problem, config: &PlanConfig) -> Result<Self, BlasError> {
if takes_faer_plan(problem) {
let native = cpueinsum::BinaryPlan::<T>::new(problem, config)
.map_err(|source| BlasError::Prepare { source })?;
if native.report().algorithm == Algorithm::Faer {
return Ok(Self::Native(native));
}
}
cpueinsum_blas::BinaryPlan::new(problem, config).map(Self::Vendor)
}
pub(crate) fn work_len(&self) -> usize {
match self {
Self::Native(_) => 0,
Self::Vendor(plan) => plan.work_len(),
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn execute_slices_accum(
&self,
exec: &mut Exec<'_>,
alpha: T,
a: (&[T], isize),
b: (&[T], isize),
beta: T,
source: SliceAccumulationSource<'_, T>,
d: (&mut [T], isize),
work: &mut [T],
) -> Result<ExecutionRoute, BlasError> {
match self {
Self::Native(plan) => plan
.execute_slices_accum(exec, alpha, a, b, beta, source, d)
.map(ExecutionRoute::Native)
.map_err(|source| BlasError::Native { source }),
Self::Vendor(plan) => {
plan.execute_slices_accum(exec, alpha, a, b, beta, source, d, work)
}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn execute_uninit_slices<'d>(
&self,
exec: &mut Exec<'_>,
alpha: T,
a: (&[T], isize),
b: (&[T], isize),
beta: T,
source: SliceAccumulationSource<'_, T>,
d: (&'d mut [core::mem::MaybeUninit<T>], isize),
work: &mut [T],
) -> Result<(&'d mut [T], ExecutionRoute), BlasError> {
match self {
Self::Native(plan) => plan
.execute_uninit_slices(exec, alpha, a, b, beta, source, d)
.map(|(initialized, route)| (initialized, ExecutionRoute::Native(route)))
.map_err(|source| BlasError::Native { source }),
Self::Vendor(plan) => {
plan.execute_uninit_slices(exec, alpha, a, b, beta, source, d, work)
}
}
}
}
fn takes_faer_plan(problem: &Problem) -> bool {
problem.dtype() == DType::C64 && row_role(problem) <= THIN_ROW_ROLE && links_accelerate()
}
fn row_role(problem: &Problem) -> usize {
problem
.roles()
.m()
.iter()
.try_fold(1usize, |rows, axis| rows.checked_mul(axis.extent()))
.unwrap_or(usize::MAX)
}
fn links_accelerate() -> bool {
cfg!(feature = "blas-accelerate")
}