nnapi-sys 0.1.1

FFI to the Android NNAPI
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::{ffi::c_void, ptr::null_mut};

use nnapi_sys::{
    ANeuralNetworksCompilation, ANeuralNetworksCompilation_create,
    ANeuralNetworksCompilation_finish, ANeuralNetworksCompilation_free, ANeuralNetworksEvent,
    ANeuralNetworksEvent_free, ANeuralNetworksEvent_wait, ANeuralNetworksExecution,
    ANeuralNetworksExecution_create, ANeuralNetworksExecution_free,
    ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setOutput,
    ANeuralNetworksExecution_startCompute, ANeuralNetworksModel, ANeuralNetworksModel_addOperand,
    ANeuralNetworksModel_addOperation, ANeuralNetworksModel_create, ANeuralNetworksModel_finish,
    ANeuralNetworksModel_free, ANeuralNetworksModel_identifyInputsAndOutputs,
    ANeuralNetworksModel_setOperandValue, ANeuralNetworksOperandType, OperandCode, OperationCode,
    ANEURALNETWORKS_FUSED_NONE,
};

fn main() {
    let tensor9x_type = ANeuralNetworksOperandType {
        type_: OperandCode::ANEURALNETWORKS_TENSOR_FLOAT32 as i32,
        dimensionCount: 1,
        dimensions: [9].as_ptr(),
        scale: 0.,
        zeroPoint: 0,
    };

    let activation_type = ANeuralNetworksOperandType {
        type_: OperandCode::ANEURALNETWORKS_INT32 as i32,
        dimensionCount: 0,
        dimensions: null_mut(),
        scale: 0.,
        zeroPoint: 0,
    };

    let mut model: *mut ANeuralNetworksModel = null_mut();

    if unsafe { ANeuralNetworksModel_create(&mut model) } != 0 {
        panic!("Failed to create model");
    }

    if unsafe { ANeuralNetworksModel_addOperand(model, &tensor9x_type) } != 0 {
        panic!("Failed to add operand 0");
    }
    unsafe { ANeuralNetworksModel_addOperand(model, &tensor9x_type) };
    unsafe { ANeuralNetworksModel_addOperand(model, &activation_type) };
    unsafe { ANeuralNetworksModel_addOperand(model, &tensor9x_type) };

    let lhs_idx = 0;
    let rhs_idx = 1;
    let activation_idx = 2;
    let out_idx = 3;

    let outputs = [out_idx];

    let none_value = ANEURALNETWORKS_FUSED_NONE;

    // set the activation operand to a none value (fixes "Graph contains at least one cycle or one never-written operand")
    if 0 != unsafe {
        ANeuralNetworksModel_setOperandValue(
            model,
            activation_idx as i32,
            &none_value as *const _ as *const _,
            4,
        )
    } {
        panic!("Failed to set activation operand value!");
    }

    if 0 != unsafe {
        // For whatever reason an activation is needed? -> [.., activation_idx]
        let inputs = [lhs_idx, rhs_idx, activation_idx];
        ANeuralNetworksModel_addOperation(
            model,
            OperationCode::ANEURALNETWORKS_ADD as i32,
            3, // inputs.len().try_into().unwrap(),
            inputs.as_ptr(),
            1, // outputs.len().try_into().unwrap(),
            outputs.as_ptr(),
        )
    } {
        panic!("Failed to add add operation!");
    }
    unsafe {
        let inputs = [lhs_idx, rhs_idx];
        ANeuralNetworksModel_identifyInputsAndOutputs(
            model,
            inputs.len().try_into().unwrap(),
            inputs.as_ptr(),
            outputs.len().try_into().unwrap(),
            outputs.as_ptr(),
        )
    };

    unsafe { ANeuralNetworksModel_finish(model) };

    let mut compilation: *mut ANeuralNetworksCompilation = null_mut();
    unsafe { ANeuralNetworksCompilation_create(model, &mut compilation) };

    unsafe { ANeuralNetworksCompilation_finish(compilation) };

    let mut run1: *mut ANeuralNetworksExecution = null_mut();
    unsafe { ANeuralNetworksExecution_create(compilation, &mut run1) };

    let lhs = [1f32, 2., 3., 4., 5., 6., 7., 8., 9.];
    let rhs = [1f32, 2., 3., 4., 5., 6., 7., 8., 9.];

    unsafe {
        ANeuralNetworksExecution_setInput(
            run1,
            0,
            null_mut(),
            lhs.as_ptr() as *const c_void,
            (lhs.len() * std::mem::size_of::<f32>()).try_into().unwrap(),
        )
    };
    unsafe {
        ANeuralNetworksExecution_setInput(
            run1,
            1,
            null_mut(),
            rhs.as_ptr() as *const c_void,
            (rhs.len() * std::mem::size_of::<f32>()).try_into().unwrap(),
        )
    };

    let mut out = [0f32; 9];

    unsafe {
        ANeuralNetworksExecution_setOutput(
            run1,
            0,
            null_mut(),
            out.as_mut_ptr() as *mut c_void,
            (out.len() * std::mem::size_of::<f32>()).try_into().unwrap(),
        )
    };

    let mut run1_end: *mut ANeuralNetworksEvent = null_mut();
    unsafe { ANeuralNetworksExecution_startCompute(run1, &mut run1_end) };

    unsafe { ANeuralNetworksEvent_wait(run1_end) };
    unsafe { ANeuralNetworksEvent_free(run1_end) };
    unsafe { ANeuralNetworksExecution_free(run1) };

    unsafe { ANeuralNetworksCompilation_free(compilation) };
    unsafe { ANeuralNetworksModel_free(model) };

    assert_eq!(out, [2f32, 4., 6., 8., 10., 12., 14., 16., 18.]);
}