blob: feb3951a4a3e53c1e9dec0fb73035512588f9ea6 [file] [log] [blame]
Michael Butler4b276a72020-08-06 23:22:35 -07001/*
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 "PreparedModel.h"
18
Michael Butler137ee992021-11-01 16:40:31 -070019#include "Burst.h"
20#include "BurstUtils.h"
Michael Butler4b276a72020-08-06 23:22:35 -070021#include "Callbacks.h"
22#include "Conversions.h"
Xusong Wang5f6bedb2021-03-03 16:20:37 -080023#include "Execution.h"
Michael Butler4b276a72020-08-06 23:22:35 -070024#include "Utils.h"
25
26#include <android/hardware/neuralnetworks/1.0/types.h>
27#include <android/hardware/neuralnetworks/1.1/types.h>
28#include <android/hardware/neuralnetworks/1.2/IPreparedModel.h>
29#include <android/hardware/neuralnetworks/1.2/types.h>
30#include <nnapi/IPreparedModel.h>
31#include <nnapi/Result.h>
32#include <nnapi/Types.h>
33#include <nnapi/hal/1.0/Conversions.h>
Michael Butler49d95e02021-10-15 18:52:52 -070034#include <nnapi/hal/1.0/HandleError.h>
Michael Butlere8645c32021-10-15 18:42:32 -070035#include <nnapi/hal/1.0/ProtectCallback.h>
Michael Butler4b276a72020-08-06 23:22:35 -070036#include <nnapi/hal/CommonUtils.h>
Michael Butler4b276a72020-08-06 23:22:35 -070037
Michael Butler76e491f2020-12-19 01:55:32 -080038#include <chrono>
Michael Butler4b276a72020-08-06 23:22:35 -070039#include <memory>
40#include <tuple>
41#include <utility>
42#include <vector>
43
Michael Butleraad934b2020-12-13 23:06:06 -080044// See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface
45// lifetimes across processes and for protecting asynchronous calls across HIDL.
46
Michael Butler4b276a72020-08-06 23:22:35 -070047namespace android::hardware::neuralnetworks::V1_2::utils {
Michael Butler4b276a72020-08-06 23:22:35 -070048
49nn::GeneralResult<std::shared_ptr<const PreparedModel>> PreparedModel::create(
Michael Butler7fd03c22020-12-06 21:50:59 -080050 sp<V1_2::IPreparedModel> preparedModel, bool executeSynchronously) {
Michael Butler4b276a72020-08-06 23:22:35 -070051 if (preparedModel == nullptr) {
Michael Butler7fd03c22020-12-06 21:50:59 -080052 return NN_ERROR() << "V1_2::utils::PreparedModel::create must have non-null preparedModel";
Michael Butler4b276a72020-08-06 23:22:35 -070053 }
54
55 auto deathHandler = NN_TRY(hal::utils::DeathHandler::create(preparedModel));
Michael Butler7fd03c22020-12-06 21:50:59 -080056 return std::make_shared<const PreparedModel>(PrivateConstructorTag{}, executeSynchronously,
57 std::move(preparedModel), std::move(deathHandler));
Michael Butler4b276a72020-08-06 23:22:35 -070058}
59
Michael Butler7fd03c22020-12-06 21:50:59 -080060PreparedModel::PreparedModel(PrivateConstructorTag /*tag*/, bool executeSynchronously,
61 sp<V1_2::IPreparedModel> preparedModel,
Michael Butler4b276a72020-08-06 23:22:35 -070062 hal::utils::DeathHandler deathHandler)
Michael Butler7fd03c22020-12-06 21:50:59 -080063 : kExecuteSynchronously(executeSynchronously),
64 kPreparedModel(std::move(preparedModel)),
65 kDeathHandler(std::move(deathHandler)) {}
Michael Butler4b276a72020-08-06 23:22:35 -070066
67nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>
68PreparedModel::executeSynchronously(const V1_0::Request& request, MeasureTiming measure) const {
Michael Butler7fd03c22020-12-06 21:50:59 -080069 auto cb = hal::utils::CallbackValue(executionCallback);
Michael Butler4b276a72020-08-06 23:22:35 -070070
71 const auto ret = kPreparedModel->executeSynchronously(request, measure, cb);
Michael Butlercca3e202020-11-22 20:25:34 -080072 HANDLE_TRANSPORT_FAILURE(ret);
Michael Butler4b276a72020-08-06 23:22:35 -070073
Michael Butler7fd03c22020-12-06 21:50:59 -080074 return cb.take();
Michael Butler4b276a72020-08-06 23:22:35 -070075}
76
77nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>
78PreparedModel::executeAsynchronously(const V1_0::Request& request, MeasureTiming measure) const {
79 const auto cb = sp<ExecutionCallback>::make();
80 const auto scoped = kDeathHandler.protectCallback(cb.get());
81
82 const auto ret = kPreparedModel->execute_1_2(request, measure, cb);
Michael Butlercca3e202020-11-22 20:25:34 -080083 const auto status = HANDLE_TRANSPORT_FAILURE(ret);
Michael Butler7fd03c22020-12-06 21:50:59 -080084 if (status != V1_0::ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
Michael Butler49d95e02021-10-15 18:52:52 -070085 HANDLE_STATUS_HIDL(status) << "execution failed with " << toString(status);
Michael Butler4b276a72020-08-06 23:22:35 -070086 }
87
88 return cb->get();
89}
90
91nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> PreparedModel::execute(
92 const nn::Request& request, nn::MeasureTiming measure,
93 const nn::OptionalTimePoint& /*deadline*/,
Miao Wang0e671f32021-10-26 20:03:05 +000094 const nn::OptionalDuration& /*loopTimeoutDuration*/,
95 const std::vector<nn::TokenValuePair>& /*hints*/,
96 const std::vector<nn::ExtensionNameAndPrefix>& /*extensionNameToPrefix*/) const {
Michael Butler4b276a72020-08-06 23:22:35 -070097 // Ensure that request is ready for IPC.
98 std::optional<nn::Request> maybeRequestInShared;
Xusong Wang5f6bedb2021-03-03 16:20:37 -080099 hal::utils::RequestRelocation relocation;
Michael Butlerff9a5a52021-10-15 16:23:20 -0700100 const nn::Request& requestInShared = NN_TRY(hal::utils::convertRequestFromPointerToShared(
101 &request, nn::kDefaultRequestMemoryAlignment, nn::kMinMemoryPadding,
102 &maybeRequestInShared, &relocation));
Michael Butler4b276a72020-08-06 23:22:35 -0700103
Michael Butlerff9a5a52021-10-15 16:23:20 -0700104 const auto hidlRequest = NN_TRY(convert(requestInShared));
105 const auto hidlMeasure = NN_TRY(convert(measure));
Michael Butler4b276a72020-08-06 23:22:35 -0700106
Xusong Wang5f6bedb2021-03-03 16:20:37 -0800107 return executeInternal(hidlRequest, hidlMeasure, relocation);
108}
109
110nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>
111PreparedModel::executeInternal(const V1_0::Request& request, MeasureTiming measure,
112 const hal::utils::RequestRelocation& relocation) const {
113 if (relocation.input) {
114 relocation.input->flush();
115 }
116
117 auto result = kExecuteSynchronously ? executeSynchronously(request, measure)
118 : executeAsynchronously(request, measure);
Michael Butler7fd03c22020-12-06 21:50:59 -0800119 auto [outputShapes, timing] = NN_TRY(std::move(result));
Michael Butler4b276a72020-08-06 23:22:35 -0700120
Xusong Wang5f6bedb2021-03-03 16:20:37 -0800121 if (relocation.output) {
122 relocation.output->flush();
123 }
Michael Butler7fd03c22020-12-06 21:50:59 -0800124 return std::make_pair(std::move(outputShapes), timing);
Michael Butler4b276a72020-08-06 23:22:35 -0700125}
126
127nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>
Miao Wang0e671f32021-10-26 20:03:05 +0000128PreparedModel::executeFenced(
129 const nn::Request& /*request*/, const std::vector<nn::SyncFence>& /*waitFor*/,
130 nn::MeasureTiming /*measure*/, const nn::OptionalTimePoint& /*deadline*/,
131 const nn::OptionalDuration& /*loopTimeoutDuration*/,
132 const nn::OptionalDuration& /*timeoutDurationAfterFence*/,
133 const std::vector<nn::TokenValuePair>& /*hints*/,
134 const std::vector<nn::ExtensionNameAndPrefix>& /*extensionNameToPrefix*/) const {
Michael Butler4b276a72020-08-06 23:22:35 -0700135 return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)
136 << "IPreparedModel::executeFenced is not supported on 1.2 HAL service";
137}
138
Xusong Wang5f6bedb2021-03-03 16:20:37 -0800139nn::GeneralResult<nn::SharedExecution> PreparedModel::createReusableExecution(
140 const nn::Request& request, nn::MeasureTiming measure,
Miao Wang0e671f32021-10-26 20:03:05 +0000141 const nn::OptionalDuration& /*loopTimeoutDuration*/,
142 const std::vector<nn::TokenValuePair>& /*hints*/,
143 const std::vector<nn::ExtensionNameAndPrefix>& /*extensionNameToPrefix*/) const {
Xusong Wang5f6bedb2021-03-03 16:20:37 -0800144 // Ensure that request is ready for IPC.
145 std::optional<nn::Request> maybeRequestInShared;
146 hal::utils::RequestRelocation relocation;
147 const nn::Request& requestInShared = NN_TRY(hal::utils::convertRequestFromPointerToShared(
Xusong Wange3d0dad2021-05-07 14:13:22 -0700148 &request, nn::kDefaultRequestMemoryAlignment, nn::kMinMemoryPadding,
149 &maybeRequestInShared, &relocation));
Xusong Wang5f6bedb2021-03-03 16:20:37 -0800150
151 auto hidlRequest = NN_TRY(convert(requestInShared));
152 auto hidlMeasure = NN_TRY(convert(measure));
153 return Execution::create(shared_from_this(), std::move(hidlRequest), std::move(relocation),
154 hidlMeasure);
155}
156
Michael Butler2a8b6792020-12-18 20:31:14 -0800157nn::GeneralResult<nn::SharedBurst> PreparedModel::configureExecutionBurst() const {
Michael Butler76e491f2020-12-19 01:55:32 -0800158 const auto pollingTimeWindow = getBurstControllerPollingTimeWindow();
Michael Butler137ee992021-11-01 16:40:31 -0700159 return Burst::create(shared_from_this(), kPreparedModel, pollingTimeWindow);
Michael Butler2a8b6792020-12-18 20:31:14 -0800160}
161
Michael Butler4b276a72020-08-06 23:22:35 -0700162std::any PreparedModel::getUnderlyingResource() const {
Michael Butler7fd03c22020-12-06 21:50:59 -0800163 sp<V1_2::IPreparedModel> resource = kPreparedModel;
Michael Butler4b276a72020-08-06 23:22:35 -0700164 return resource;
165}
166
167} // namespace android::hardware::neuralnetworks::V1_2::utils