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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "utils.h"
#include "logger.h"
#include <stdio.h>
#include <stdlib.h>
error
wasm_load(char *model_name, graph *g, execution_target target)
{
FILE *pFile = fopen(model_name, "r");
if (pFile == NULL)
return invalid_argument;
uint8_t *buffer;
size_t result;
// allocate memory to contain the whole file:
buffer = (uint8_t *)malloc(sizeof(uint8_t) * MAX_MODEL_SIZE);
if (buffer == NULL) {
fclose(pFile);
return missing_memory;
}
result = fread(buffer, 1, MAX_MODEL_SIZE, pFile);
if (result <= 0) {
fclose(pFile);
free(buffer);
return missing_memory;
}
graph_builder_array arr;
arr.size = 1;
arr.buf = (graph_builder *)malloc(sizeof(graph_builder));
if (arr.buf == NULL) {
fclose(pFile);
free(buffer);
return missing_memory;
}
arr.buf[0].size = result;
arr.buf[0].buf = buffer;
error res = load(&arr, tensorflowlite, target, g);
fclose(pFile);
free(buffer);
free(arr.buf);
return res;
}
error
wasm_init_execution_context(graph g, graph_execution_context *ctx)
{
return init_execution_context(g, ctx);
}
error
wasm_set_input(graph_execution_context ctx, float *input_tensor, uint32_t *dim)
{
tensor_dimensions dims;
dims.size = INPUT_TENSOR_DIMS;
dims.buf = (uint32_t *)malloc(dims.size * sizeof(uint32_t));
if (dims.buf == NULL)
return missing_memory;
tensor tensor;
tensor.dimensions = &dims;
for (int i = 0; i < tensor.dimensions->size; ++i)
tensor.dimensions->buf[i] = dim[i];
tensor.type = fp32;
tensor.data = (uint8_t *)input_tensor;
error err = set_input(ctx, 0, &tensor);
free(dims.buf);
return err;
}
error
wasm_compute(graph_execution_context ctx)
{
return compute(ctx);
}
error
wasm_get_output(graph_execution_context ctx, uint32_t index, float *out_tensor,
uint32_t *out_size)
{
return get_output(ctx, index, (uint8_t *)out_tensor, out_size);
}
float *
run_inference(execution_target target, float *input, uint32_t *input_size,
uint32_t *output_size, char *model_name,
uint32_t num_output_tensors)
{
graph graph;
if (wasm_load(model_name, &graph, target) != success) {
NN_ERR_PRINTF("Error when loading model.");
exit(1);
}
graph_execution_context ctx;
if (wasm_init_execution_context(graph, &ctx) != success) {
NN_ERR_PRINTF("Error when initialixing execution context.");
exit(1);
}
if (wasm_set_input(ctx, input, input_size) != success) {
NN_ERR_PRINTF("Error when setting input tensor.");
exit(1);
}
if (wasm_compute(ctx) != success) {
NN_ERR_PRINTF("Error when running inference.");
exit(1);
}
float *out_tensor = (float *)malloc(sizeof(float) * MAX_OUTPUT_TENSOR_SIZE);
if (out_tensor == NULL) {
NN_ERR_PRINTF("Error when allocating memory for output tensor.");
exit(1);
}
uint32_t offset = 0;
for (int i = 0; i < num_output_tensors; ++i) {
*output_size = MAX_OUTPUT_TENSOR_SIZE - *output_size;
if (wasm_get_output(ctx, i, &out_tensor[offset], output_size)
!= success) {
NN_ERR_PRINTF("Error when getting output.");
exit(1);
}
offset += *output_size;
}
*output_size = offset;
return out_tensor;
}
input_info
create_input(int *dims)
{
input_info input = { .dim = NULL, .input_tensor = NULL, .elements = 1 };
input.dim = malloc(INPUT_TENSOR_DIMS * sizeof(uint32_t));
if (input.dim)
for (int i = 0; i < INPUT_TENSOR_DIMS; ++i) {
input.dim[i] = dims[i];
input.elements *= dims[i];
}
input.input_tensor = malloc(input.elements * sizeof(float));
for (int i = 0; i < input.elements; ++i)
input.input_tensor[i] = i;
return input;
}
|
