tenferro-internal-cpu-kernels 0.9.0

Internal ordinary CPU kernel implementations for tenferro-cpu.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use tenferro_tensor::{DynRank, Host, TypedTensor};

use super::{scalar_binary_into, scalar_fold, AddOp, SubOp};
use strided_kernel::Exec;

fn tensor(values: &[f64]) -> TypedTensor<f64, DynRank, Host> {
    TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![values.len()], values.to_vec())
        .unwrap()
}

#[test]
fn elementwise_rejects_a_destination_of_the_wrong_shape() {
    let lhs = tensor(&[1.0, 2.0]);
    let rhs = tensor(&[1.0, 2.0]);
    let mut destination = tensor(&[0.0]);

    let error =
        scalar_binary_into::<f64, AddOp>("add", &mut destination, &lhs, &rhs, Exec::serial())
            .expect_err("destination shape must match");

    assert_eq!(destination.as_slice(), &[0.0]);
    assert_eq!(
        error.kind(),
        tenferro_tensor::ErrorKind::Validation(tenferro_tensor_core::ValidationKind::ShapeMismatch)
    );
}

#[test]
fn elementwise_rejects_operands_of_different_shapes() {
    let lhs = tensor(&[1.0, 2.0]);
    let rhs = tensor(&[1.0]);
    let mut destination = tensor(&[0.0, 0.0]);

    let error =
        scalar_binary_into::<f64, AddOp>("add", &mut destination, &lhs, &rhs, Exec::serial())
            .expect_err("operand shapes must match");

    assert_eq!(destination.as_slice(), &[0.0, 0.0]);
    assert_eq!(
        error.kind(),
        tenferro_tensor::ErrorKind::Validation(tenferro_tensor_core::ValidationKind::ShapeMismatch)
    );
}

#[test]
fn elementwise_handles_an_empty_destination() {
    let lhs: TypedTensor<f64, DynRank, Host> =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![0], Vec::new()).unwrap();
    let rhs: TypedTensor<f64, DynRank, Host> =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![0], Vec::new()).unwrap();
    let mut destination: TypedTensor<f64, DynRank, Host> =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![0], Vec::new()).unwrap();

    scalar_binary_into::<f64, AddOp>("add", &mut destination, &lhs, &rhs, Exec::serial()).unwrap();

    assert!(destination.as_slice().is_empty());
}

#[test]
fn fold_uses_the_caller_operation_and_initial_value() {
    let values = tensor(&[1.0, 2.0, 3.0]);

    assert_eq!(
        scalar_fold::<f64, AddOp>("sum", &values, 0.0, Exec::serial()).unwrap(),
        6.0
    );
    assert_eq!(
        scalar_fold::<f64, AddOp>("sum", &values, 10.0, Exec::serial()).unwrap(),
        16.0
    );
    assert_eq!(
        scalar_fold::<f64, SubOp>("diff", &values, 0.0, Exec::serial()).unwrap(),
        -6.0
    );
}

#[test]
fn integer_arithmetic_through_the_shared_entry_point_wraps() {
    use crate::scalar_ops::{scalar_binary_into, scalar_fold, AddOp, MulOp, SubOp};
    use tenferro_tensor::{DynRank, Host, TypedTensor};

    // The preset path wraps for integers, and the shared entry points have to agree with it in
    // every build: the operator would panic on overflow in a debug build instead.
    let maximum = TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![i32::MAX])
        .expect("shape");
    let one =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![1]).expect("shape");
    let mut destination =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![0]).expect("shape");
    scalar_binary_into::<i32, AddOp>("add", &mut destination, &maximum, &one, Exec::serial())
        .expect("addition");
    assert_eq!(destination.as_slice(), &[i32::MIN]);

    let minimum = TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![i32::MIN])
        .expect("shape");
    scalar_binary_into::<i32, SubOp>("sub", &mut destination, &minimum, &one, Exec::serial())
        .expect("subtraction");
    assert_eq!(destination.as_slice(), &[i32::MAX]);

    let large = TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![i64::MAX])
        .expect("shape");
    let two =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![2]).expect("shape");
    let mut destination =
        TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![1], vec![0]).expect("shape");
    scalar_binary_into::<i64, MulOp>("mul", &mut destination, &large, &two, Exec::serial())
        .expect("product");
    assert_eq!(destination.as_slice(), &[i64::MAX.wrapping_mul(2)]);

    // The reduction folds through the same contract.
    let total = scalar_fold::<i32, AddOp>(
        "sum",
        &TypedTensor::<_, DynRank, Host>::from_host_vec_col_major(vec![2], vec![i32::MAX, 1])
            .expect("shape"),
        0,
        Exec::serial(),
    )
    .expect("reduction");
    assert_eq!(total, i32::MIN);
}