Trait TensorBackendCapability 

pub trait TensorBackendCapability {
    // Required methods
    fn backend_id(&self) -> BackendId;
    fn capabilities(&self) -> &'static [OperationCapability];

    // Provided methods
    fn capability(&self, query: CapabilityQuery) -> Option<OperationCapability> { ... }
    fn require_capability(
        &self,
        query: CapabilityQuery,
        axis: CapabilityAxis,
    ) -> Result<OperationCapability> { ... }
}

Backend capability query surface.

Examples

use tenferro_core_ops::PrimitiveOpKind;
use tenferro_tensor::{
    BackendId, CapabilityQuery, DType, OperationCapability, SupportLevel,
    TensorBackendCapability,
};

struct Backend;

const ENTRIES: &[OperationCapability] = &[OperationCapability {
    backend: BackendId::Cpu,
    op: PrimitiveOpKind::Add,
    dtype: DType::F32,
    output_dtype: DType::F32,
    result: SupportLevel::Native,
    read_inputs: SupportLevel::Native,
    write_output: SupportLevel::Native,
    strided_output: SupportLevel::Native,
    accumulation: SupportLevel::Unsupported,
}];

impl TensorBackendCapability for Backend {
    fn backend_id(&self) -> BackendId { BackendId::Cpu }
    fn capabilities(&self) -> &'static [OperationCapability] { ENTRIES }
}

assert!(Backend
    .capability(CapabilityQuery::new(PrimitiveOpKind::Add, DType::F32))
    .is_some());

Required Methods

fn backend_id(&self) -> BackendId

fn capabilities(&self) -> &'static [OperationCapability]

Provided Methods

fn capability(&self, query: CapabilityQuery) -> Option<OperationCapability>

Look up one operation/dtype capability for this backend.

Examples

use tenferro_core_ops::PrimitiveOpKind;
use tenferro_tensor::{
    BackendId, CapabilityQuery, DType, OperationCapability, SupportLevel,
    TensorBackendCapability,
};

struct Backend;
const ENTRIES: &[OperationCapability] = &[OperationCapability {
    backend: BackendId::Cpu,
    op: PrimitiveOpKind::Mul,
    dtype: DType::I64,
    output_dtype: DType::I64,
    result: SupportLevel::Native,
    read_inputs: SupportLevel::Native,
    write_output: SupportLevel::Unsupported,
    strided_output: SupportLevel::Unsupported,
    accumulation: SupportLevel::Unsupported,
}];
impl TensorBackendCapability for Backend {
    fn backend_id(&self) -> BackendId { BackendId::Cpu }
    fn capabilities(&self) -> &'static [OperationCapability] { ENTRIES }
}

let entry = Backend
    .capability(CapabilityQuery::new(PrimitiveOpKind::Mul, DType::I64))
    .unwrap();
assert_eq!(entry.result, SupportLevel::Native);

fn require_capability( &self, query: CapabilityQuery, axis: CapabilityAxis, ) -> Result<OperationCapability>

Require support for one operation/dtype/axis, returning a structured unsupported error otherwise.

Examples

use tenferro_core_ops::PrimitiveOpKind;
use tenferro_tensor::{
    BackendId, CapabilityAxis, CapabilityQuery, DType, Error, OperationCapability,
    SupportLevel, TensorBackendCapability,
};

struct Backend;
const ENTRIES: &[OperationCapability] = &[OperationCapability {
    backend: BackendId::Cuda,
    op: PrimitiveOpKind::Neg,
    dtype: DType::I32,
    output_dtype: DType::I32,
    result: SupportLevel::Unsupported,
    read_inputs: SupportLevel::Unsupported,
    write_output: SupportLevel::Unsupported,
    strided_output: SupportLevel::Unsupported,
    accumulation: SupportLevel::Unsupported,
}];
impl TensorBackendCapability for Backend {
    fn backend_id(&self) -> BackendId { BackendId::Cuda }
    fn capabilities(&self) -> &'static [OperationCapability] { ENTRIES }
}

let err = Backend
    .require_capability(
        CapabilityQuery::new(PrimitiveOpKind::Neg, DType::I32),
        CapabilityAxis::OwnedResult,
    )
    .unwrap_err();
assert!(matches!(err, Error::UnsupportedOpDType { backend: BackendId::Cuda, .. }));

Implementors