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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
/*
* Copyright (c) 2019 Samsung Electronics Co., Ltd. All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __API_NNFW_API_INTERNAL_H__
#define __API_NNFW_API_INTERNAL_H__
#include "nnfw.h"
#include "nnfw_experimental.h"
#include <util/TracingCtx.h>
#include <string>
#include <memory>
#include <thread>
#include <vector>
namespace onert
{
namespace api
{
class CustomKernelRegistry;
} // namespace api
namespace exec
{
class Execution;
} // namespace exec
namespace ir
{
struct IGraph;
class Model;
class NNPkg;
} // namespace ir
namespace compiler
{
struct CompilerArtifact;
class CompilerOptions;
} // namespace compiler
namespace odc
{
class QuantizeManager;
} // namespace odc
} // namespace onert
struct nnfw_session
{
private:
/**
* @brief Enum class to express the session's state
*
* State transition diagram:
*
* +--------------+
* | INITIALIZED |
* +--------------+
* |
* | load_model
* v
* +--------------+
* | MODEL_LOADED |
* +--------------+
* |
* | prepare
* v
* +--------------+
* | PREPARED | --------+
* +--------------+ |
* | |
* | run |
* v |
* +--------------+ run |
* | | -----+ |
* +-----> | FINISHED_RUN | | | run_async
* | | | <----+ |
* | +--------------+ |
* | | |
* | await | run_async |
* | v |
* | +--------------+ |
* +------ | RUNNING | <-------+
* +--------------+
*/
enum class State
{
INITIALIZED, //< Session is initialized and nothing has done to it
MODEL_LOADED, //< Model is loaded
PREPARED, //< Prepared(compiled) for execution
RUNNING, //< Execution is in progress (only for asynchronous execution)
FINISHED_RUN, //< Executed at least once
PREPARED_TRAINING, //< Prepared for training
FINISHED_TRAINING //< Trained at least once
};
public:
/**
* @brief Factory method. It creates and initialize nnfw_session
*
* @note Use factory instead of constructor to get status
*/
static NNFW_STATUS create(nnfw_session **session);
private:
nnfw_session();
public:
~nnfw_session();
NNFW_STATUS load_model_from_nnpackage(const char *package_file_path);
NNFW_STATUS prepare();
NNFW_STATUS prepare_pipeline(const char *map_file_path);
NNFW_STATUS run();
NNFW_STATUS run_async();
NNFW_STATUS await();
NNFW_STATUS set_input(uint32_t index, NNFW_TYPE type, const void *buffer, size_t length);
NNFW_STATUS set_output(uint32_t index, NNFW_TYPE type, void *buffer, size_t length);
NNFW_STATUS input_size(uint32_t *number);
NNFW_STATUS output_size(uint32_t *number);
NNFW_STATUS set_input_layout(uint32_t index, NNFW_LAYOUT layout);
NNFW_STATUS set_output_layout(uint32_t index, NNFW_LAYOUT layout);
NNFW_STATUS apply_tensorinfo(uint32_t index, nnfw_tensorinfo ti); // Will be deprecated
NNFW_STATUS set_input_tensorinfo(uint32_t index, const nnfw_tensorinfo *ti);
NNFW_STATUS input_tensorinfo(uint32_t index, nnfw_tensorinfo *ti);
NNFW_STATUS output_tensorinfo(uint32_t index, nnfw_tensorinfo *ti);
NNFW_STATUS set_available_backends(const char *backends);
NNFW_STATUS set_op_backend(const char *op, const char *backend);
//
// Internal-only API
//
NNFW_STATUS set_config(const char *key, const char *value);
NNFW_STATUS get_config(const char *key, char *value, size_t value_size);
NNFW_STATUS load_circle_from_buffer(uint8_t *buffer, size_t size);
NNFW_STATUS load_model_from_modelfile(const char *file_path);
//
// Experimental API
//
NNFW_STATUS push_pipeline_input(std::vector<void *> *inputs, std::vector<uint32_t> *lengths);
NNFW_STATUS pop_pipeline_output(std::vector<void *> *outputs);
NNFW_STATUS register_custom_operation(const std::string &id, nnfw_custom_eval eval_func);
NNFW_STATUS input_tensorindex(const char *tensorname, uint32_t *index);
NNFW_STATUS output_tensorindex(const char *tensorname, uint32_t *index);
/**
* @brief Set backends with string-encoded mapping from operation index to backend type
* (cpu, acl_cl)
*/
NNFW_STATUS set_backends_per_operation(const char *backend_settings);
#ifdef ONERT_TRAIN
NNFW_STATUS train_prepare(const nnfw_train_info *info);
NNFW_STATUS train_input_tensorinfo(uint32_t index, nnfw_tensorinfo *ti);
NNFW_STATUS train_expected_tensorinfo(uint32_t index, nnfw_tensorinfo *ti);
NNFW_STATUS train_set_input(uint32_t index, const void *input,
const nnfw_tensorinfo *input_tensorinfo);
NNFW_STATUS train_set_expected(uint32_t index, const void *expected,
const nnfw_tensorinfo *expected_tensorinfo);
NNFW_STATUS train_run(bool update_weights);
NNFW_STATUS train_get_loss(uint32_t index, float *loss);
NNFW_STATUS train_export_circle(const char *path);
#endif // ONERT_TRAIN
NNFW_STATUS set_quantization_type(NNFW_QUANTIZE_TYPE qtype);
NNFW_STATUS set_quantized_model_path(const char *path);
NNFW_STATUS quantize();
private:
const onert::ir::IGraph *primary_subgraph();
uint32_t getInputSize();
uint32_t getOutputSize();
bool isStateInitialized();
bool isStateModelLoaded();
bool isStatePrepared();
bool isStateRunning();
bool isStateFinishedRun();
bool isStatePreparedOrFinishedRun();
#ifdef ONERT_TRAIN
bool isStatePreparedTraining();
bool isStateFinishedTraining();
bool isStatePreparedOrFinishedTraining();
#endif // ONERT_TRAIN
private:
State _state{State::INITIALIZED};
std::shared_ptr<onert::ir::NNPkg> _nnpkg;
std::vector<std::unique_ptr<onert::compiler::CompilerOptions>> _coptions;
std::shared_ptr<onert::compiler::CompilerArtifact> _compiler_artifact;
std::unique_ptr<onert::exec::Execution> _execution;
std::shared_ptr<onert::api::CustomKernelRegistry> _kernel_registry;
std::vector<std::thread> _threads;
#ifdef ONERT_TRAIN
uint32_t _training_step{0};
#endif // ONERT_TRAIN
std::unique_ptr<onert::odc::QuantizeManager> _quant_manager;
};
#endif // __API_NNFW_API_INTERNAL_H__
|
