1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "Conversions.h"
18
19 #include <android-base/logging.h>
20 #include <android/hardware/neuralnetworks/1.0/types.h>
21 #include <android/hardware/neuralnetworks/1.1/types.h>
22 #include <nnapi/OperandTypes.h>
23 #include <nnapi/OperationTypes.h>
24 #include <nnapi/Result.h>
25 #include <nnapi/SharedMemory.h>
26 #include <nnapi/TypeUtils.h>
27 #include <nnapi/Types.h>
28 #include <nnapi/Validation.h>
29 #include <nnapi/hal/1.0/Conversions.h>
30 #include <nnapi/hal/CommonUtils.h>
31
32 #include <algorithm>
33 #include <functional>
34 #include <iterator>
35 #include <type_traits>
36 #include <utility>
37
38 #include "Utils.h"
39
40 namespace android::nn {
41 namespace {
42
43 using hardware::hidl_vec;
44
45 template <typename Input>
46 using UnvalidatedConvertOutput =
47 std::decay_t<decltype(unvalidatedConvert(std::declval<Input>()).value())>;
48
49 template <typename Type>
unvalidatedConvert(const hidl_vec<Type> & arguments)50 GeneralResult<std::vector<UnvalidatedConvertOutput<Type>>> unvalidatedConvert(
51 const hidl_vec<Type>& arguments) {
52 std::vector<UnvalidatedConvertOutput<Type>> canonical;
53 canonical.reserve(arguments.size());
54 for (const auto& argument : arguments) {
55 canonical.push_back(NN_TRY(nn::unvalidatedConvert(argument)));
56 }
57 return canonical;
58 }
59
60 template <typename Type>
validatedConvert(const Type & halObject)61 GeneralResult<UnvalidatedConvertOutput<Type>> validatedConvert(const Type& halObject) {
62 auto canonical = NN_TRY(nn::unvalidatedConvert(halObject));
63 NN_TRY(hal::V1_1::utils::compliantVersion(canonical));
64 return canonical;
65 }
66
67 } // anonymous namespace
68
unvalidatedConvert(const hal::V1_1::OperationType & operationType)69 GeneralResult<OperationType> unvalidatedConvert(const hal::V1_1::OperationType& operationType) {
70 return static_cast<OperationType>(operationType);
71 }
72
unvalidatedConvert(const hal::V1_1::Capabilities & capabilities)73 GeneralResult<Capabilities> unvalidatedConvert(const hal::V1_1::Capabilities& capabilities) {
74 const auto quantized8Performance =
75 NN_TRY(unvalidatedConvert(capabilities.quantized8Performance));
76 const auto float32Performance = NN_TRY(unvalidatedConvert(capabilities.float32Performance));
77 const auto relaxedFloat32toFloat16Performance =
78 NN_TRY(unvalidatedConvert(capabilities.relaxedFloat32toFloat16Performance));
79
80 auto table = hal::utils::makeQuantized8PerformanceConsistentWithP(float32Performance,
81 quantized8Performance);
82
83 return Capabilities{
84 .relaxedFloat32toFloat16PerformanceScalar = relaxedFloat32toFloat16Performance,
85 .relaxedFloat32toFloat16PerformanceTensor = relaxedFloat32toFloat16Performance,
86 .operandPerformance = std::move(table),
87 };
88 }
89
unvalidatedConvert(const hal::V1_1::Operation & operation)90 GeneralResult<Operation> unvalidatedConvert(const hal::V1_1::Operation& operation) {
91 return Operation{
92 .type = NN_TRY(unvalidatedConvert(operation.type)),
93 .inputs = operation.inputs,
94 .outputs = operation.outputs,
95 };
96 }
97
unvalidatedConvert(const hal::V1_1::Model & model)98 GeneralResult<Model> unvalidatedConvert(const hal::V1_1::Model& model) {
99 auto operations = NN_TRY(unvalidatedConvert(model.operations));
100
101 // Verify number of consumers.
102 const auto numberOfConsumers =
103 NN_TRY(hal::utils::countNumberOfConsumers(model.operands.size(), operations));
104 CHECK(model.operands.size() == numberOfConsumers.size());
105 for (size_t i = 0; i < model.operands.size(); ++i) {
106 if (model.operands[i].numberOfConsumers != numberOfConsumers[i]) {
107 return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)
108 << "Invalid numberOfConsumers for operand " << i << ", expected "
109 << numberOfConsumers[i] << " but found " << model.operands[i].numberOfConsumers;
110 }
111 }
112
113 auto main = Model::Subgraph{
114 .operands = NN_TRY(unvalidatedConvert(model.operands)),
115 .operations = std::move(operations),
116 .inputIndexes = model.inputIndexes,
117 .outputIndexes = model.outputIndexes,
118 };
119
120 return Model{
121 .main = std::move(main),
122 .operandValues = NN_TRY(unvalidatedConvert(model.operandValues)),
123 .pools = NN_TRY(unvalidatedConvert(model.pools)),
124 .relaxComputationFloat32toFloat16 = model.relaxComputationFloat32toFloat16,
125 };
126 }
127
unvalidatedConvert(const hal::V1_1::ExecutionPreference & executionPreference)128 GeneralResult<ExecutionPreference> unvalidatedConvert(
129 const hal::V1_1::ExecutionPreference& executionPreference) {
130 return static_cast<ExecutionPreference>(executionPreference);
131 }
132
convert(const hal::V1_1::Capabilities & capabilities)133 GeneralResult<Capabilities> convert(const hal::V1_1::Capabilities& capabilities) {
134 return validatedConvert(capabilities);
135 }
136
convert(const hal::V1_1::Model & model)137 GeneralResult<Model> convert(const hal::V1_1::Model& model) {
138 return validatedConvert(model);
139 }
140
convert(const hal::V1_1::ExecutionPreference & executionPreference)141 GeneralResult<ExecutionPreference> convert(
142 const hal::V1_1::ExecutionPreference& executionPreference) {
143 return validatedConvert(executionPreference);
144 }
145
146 } // namespace android::nn
147
148 namespace android::hardware::neuralnetworks::V1_1::utils {
149 namespace {
150
151 using utils::unvalidatedConvert;
152
unvalidatedConvert(const nn::Capabilities::PerformanceInfo & performanceInfo)153 nn::GeneralResult<V1_0::PerformanceInfo> unvalidatedConvert(
154 const nn::Capabilities::PerformanceInfo& performanceInfo) {
155 return V1_0::utils::unvalidatedConvert(performanceInfo);
156 }
157
unvalidatedConvert(const nn::Operand & operand)158 nn::GeneralResult<V1_0::Operand> unvalidatedConvert(const nn::Operand& operand) {
159 return V1_0::utils::unvalidatedConvert(operand);
160 }
161
unvalidatedConvert(const nn::Model::OperandValues & operandValues)162 nn::GeneralResult<hidl_vec<uint8_t>> unvalidatedConvert(
163 const nn::Model::OperandValues& operandValues) {
164 return V1_0::utils::unvalidatedConvert(operandValues);
165 }
166
unvalidatedConvert(const nn::SharedMemory & memory)167 nn::GeneralResult<hidl_memory> unvalidatedConvert(const nn::SharedMemory& memory) {
168 return V1_0::utils::unvalidatedConvert(memory);
169 }
170
171 template <typename Input>
172 using UnvalidatedConvertOutput =
173 std::decay_t<decltype(unvalidatedConvert(std::declval<Input>()).value())>;
174
175 template <typename Type>
unvalidatedConvert(const std::vector<Type> & arguments)176 nn::GeneralResult<hidl_vec<UnvalidatedConvertOutput<Type>>> unvalidatedConvert(
177 const std::vector<Type>& arguments) {
178 hidl_vec<UnvalidatedConvertOutput<Type>> halObject(arguments.size());
179 for (size_t i = 0; i < arguments.size(); ++i) {
180 halObject[i] = NN_TRY(unvalidatedConvert(arguments[i]));
181 }
182 return halObject;
183 }
184
185 template <typename Type>
validatedConvert(const Type & canonical)186 nn::GeneralResult<UnvalidatedConvertOutput<Type>> validatedConvert(const Type& canonical) {
187 NN_TRY(compliantVersion(canonical));
188 return unvalidatedConvert(canonical);
189 }
190
191 } // anonymous namespace
192
unvalidatedConvert(const nn::OperationType & operationType)193 nn::GeneralResult<OperationType> unvalidatedConvert(const nn::OperationType& operationType) {
194 return static_cast<OperationType>(operationType);
195 }
196
unvalidatedConvert(const nn::Capabilities & capabilities)197 nn::GeneralResult<Capabilities> unvalidatedConvert(const nn::Capabilities& capabilities) {
198 return Capabilities{
199 .float32Performance = NN_TRY(unvalidatedConvert(
200 capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_FLOAT32))),
201 .quantized8Performance = NN_TRY(unvalidatedConvert(
202 capabilities.operandPerformance.lookup(nn::OperandType::TENSOR_QUANT8_ASYMM))),
203 .relaxedFloat32toFloat16Performance = NN_TRY(
204 unvalidatedConvert(capabilities.relaxedFloat32toFloat16PerformanceTensor)),
205 };
206 }
207
unvalidatedConvert(const nn::Operation & operation)208 nn::GeneralResult<Operation> unvalidatedConvert(const nn::Operation& operation) {
209 return Operation{
210 .type = NN_TRY(unvalidatedConvert(operation.type)),
211 .inputs = operation.inputs,
212 .outputs = operation.outputs,
213 };
214 }
215
unvalidatedConvert(const nn::Model & model)216 nn::GeneralResult<Model> unvalidatedConvert(const nn::Model& model) {
217 if (!hal::utils::hasNoPointerData(model)) {
218 return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT)
219 << "Mdoel cannot be unvalidatedConverted because it contains pointer-based memory";
220 }
221
222 auto operands = NN_TRY(unvalidatedConvert(model.main.operands));
223
224 // Update number of consumers.
225 const auto numberOfConsumers =
226 NN_TRY(hal::utils::countNumberOfConsumers(operands.size(), model.main.operations));
227 CHECK(operands.size() == numberOfConsumers.size());
228 for (size_t i = 0; i < operands.size(); ++i) {
229 operands[i].numberOfConsumers = numberOfConsumers[i];
230 }
231
232 return Model{
233 .operands = std::move(operands),
234 .operations = NN_TRY(unvalidatedConvert(model.main.operations)),
235 .inputIndexes = model.main.inputIndexes,
236 .outputIndexes = model.main.outputIndexes,
237 .operandValues = NN_TRY(unvalidatedConvert(model.operandValues)),
238 .pools = NN_TRY(unvalidatedConvert(model.pools)),
239 .relaxComputationFloat32toFloat16 = model.relaxComputationFloat32toFloat16,
240 };
241 }
242
unvalidatedConvert(const nn::ExecutionPreference & executionPreference)243 nn::GeneralResult<ExecutionPreference> unvalidatedConvert(
244 const nn::ExecutionPreference& executionPreference) {
245 return static_cast<ExecutionPreference>(executionPreference);
246 }
247
convert(const nn::Capabilities & capabilities)248 nn::GeneralResult<Capabilities> convert(const nn::Capabilities& capabilities) {
249 return validatedConvert(capabilities);
250 }
251
convert(const nn::Model & model)252 nn::GeneralResult<Model> convert(const nn::Model& model) {
253 return validatedConvert(model);
254 }
255
convert(const nn::ExecutionPreference & executionPreference)256 nn::GeneralResult<ExecutionPreference> convert(const nn::ExecutionPreference& executionPreference) {
257 return validatedConvert(executionPreference);
258 }
259
convert(const nn::DeviceStatus & deviceStatus)260 nn::GeneralResult<V1_0::DeviceStatus> convert(const nn::DeviceStatus& deviceStatus) {
261 return V1_0::utils::convert(deviceStatus);
262 }
263
convert(const nn::Request & request)264 nn::GeneralResult<V1_0::Request> convert(const nn::Request& request) {
265 return V1_0::utils::convert(request);
266 }
267
convert(const nn::ErrorStatus & status)268 nn::GeneralResult<V1_0::ErrorStatus> convert(const nn::ErrorStatus& status) {
269 return V1_0::utils::convert(status);
270 }
271
272 } // namespace android::hardware::neuralnetworks::V1_1::utils
273