blob: 191560786f8d3e0b1875ddf899d55ffef2724c74 [file] [log] [blame]
Lev Proleev900c28a2021-01-26 19:40:20 +00001/*
2 * Copyright (C) 2021 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 Butler7a9d6092021-03-10 21:57:13 -080019#include "Burst.h"
Lev Proleev900c28a2021-01-26 19:40:20 +000020#include "Callbacks.h"
21#include "Conversions.h"
Xusong Wang727a7b22021-03-03 16:20:37 -080022#include "Execution.h"
23#include "ProtectCallback.h"
Lev Proleev900c28a2021-01-26 19:40:20 +000024#include "Utils.h"
25
Xusong Wang727a7b22021-03-03 16:20:37 -080026#include <aidl/android/hardware/neuralnetworks/Request.h>
Lev Proleev900c28a2021-01-26 19:40:20 +000027#include <android/binder_auto_utils.h>
28#include <nnapi/IPreparedModel.h>
29#include <nnapi/Result.h>
30#include <nnapi/TypeUtils.h>
31#include <nnapi/Types.h>
Lev Proleev900c28a2021-01-26 19:40:20 +000032#include <nnapi/hal/CommonUtils.h>
33#include <nnapi/hal/HandleError.h>
34
35#include <memory>
36#include <tuple>
37#include <utility>
38#include <vector>
39
40// See hardware/interfaces/neuralnetworks/utils/README.md for more information on AIDL interface
41// lifetimes across processes and for protecting asynchronous calls across AIDL.
42
43namespace aidl::android::hardware::neuralnetworks::utils {
44namespace {
45
46nn::GeneralResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> convertExecutionResults(
47 const std::vector<OutputShape>& outputShapes, const Timing& timing) {
48 return std::make_pair(NN_TRY(nn::convert(outputShapes)), NN_TRY(nn::convert(timing)));
49}
50
51nn::GeneralResult<std::pair<nn::Timing, nn::Timing>> convertFencedExecutionResults(
52 ErrorStatus status, const aidl_hal::Timing& timingLaunched,
53 const aidl_hal::Timing& timingFenced) {
54 HANDLE_HAL_STATUS(status) << "fenced execution callback info failed with " << toString(status);
55 return std::make_pair(NN_TRY(nn::convert(timingLaunched)), NN_TRY(nn::convert(timingFenced)));
56}
57
58} // namespace
59
60nn::GeneralResult<std::shared_ptr<const PreparedModel>> PreparedModel::create(
61 std::shared_ptr<aidl_hal::IPreparedModel> preparedModel) {
62 if (preparedModel == nullptr) {
63 return NN_ERROR()
64 << "aidl_hal::utils::PreparedModel::create must have non-null preparedModel";
65 }
66
67 return std::make_shared<const PreparedModel>(PrivateConstructorTag{}, std::move(preparedModel));
68}
69
70PreparedModel::PreparedModel(PrivateConstructorTag /*tag*/,
71 std::shared_ptr<aidl_hal::IPreparedModel> preparedModel)
72 : kPreparedModel(std::move(preparedModel)) {}
73
74nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> PreparedModel::execute(
75 const nn::Request& request, nn::MeasureTiming measure,
76 const nn::OptionalTimePoint& deadline,
77 const nn::OptionalDuration& loopTimeoutDuration) const {
78 // Ensure that request is ready for IPC.
79 std::optional<nn::Request> maybeRequestInShared;
Xusong Wang727a7b22021-03-03 16:20:37 -080080 hal::utils::RequestRelocation relocation;
81 const nn::Request& requestInShared =
82 NN_TRY(hal::utils::makeExecutionFailure(hal::utils::convertRequestFromPointerToShared(
83 &request, &maybeRequestInShared, &relocation)));
Lev Proleev900c28a2021-01-26 19:40:20 +000084
85 const auto aidlRequest = NN_TRY(hal::utils::makeExecutionFailure(convert(requestInShared)));
86 const auto aidlMeasure = NN_TRY(hal::utils::makeExecutionFailure(convert(measure)));
87 const auto aidlDeadline = NN_TRY(hal::utils::makeExecutionFailure(convert(deadline)));
88 const auto aidlLoopTimeoutDuration =
89 NN_TRY(hal::utils::makeExecutionFailure(convert(loopTimeoutDuration)));
Xusong Wang727a7b22021-03-03 16:20:37 -080090 return executeInternal(aidlRequest, aidlMeasure, aidlDeadline, aidlLoopTimeoutDuration,
91 relocation);
92}
93
94nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>
95PreparedModel::executeInternal(const Request& request, bool measure, int64_t deadline,
96 int64_t loopTimeoutDuration,
97 const hal::utils::RequestRelocation& relocation) const {
98 if (relocation.input) {
99 relocation.input->flush();
100 }
Lev Proleev900c28a2021-01-26 19:40:20 +0000101
102 ExecutionResult executionResult;
Xusong Wang727a7b22021-03-03 16:20:37 -0800103 const auto ret = kPreparedModel->executeSynchronously(request, measure, deadline,
104 loopTimeoutDuration, &executionResult);
Lev Proleev900c28a2021-01-26 19:40:20 +0000105 HANDLE_ASTATUS(ret) << "executeSynchronously failed";
106 if (!executionResult.outputSufficientSize) {
107 auto canonicalOutputShapes =
108 nn::convert(executionResult.outputShapes).value_or(std::vector<nn::OutputShape>{});
109 return NN_ERROR(nn::ErrorStatus::OUTPUT_INSUFFICIENT_SIZE, std::move(canonicalOutputShapes))
110 << "execution failed with " << nn::ErrorStatus::OUTPUT_INSUFFICIENT_SIZE;
111 }
112 auto [outputShapes, timing] = NN_TRY(hal::utils::makeExecutionFailure(
113 convertExecutionResults(executionResult.outputShapes, executionResult.timing)));
114
Xusong Wang727a7b22021-03-03 16:20:37 -0800115 if (relocation.output) {
116 relocation.output->flush();
117 }
Lev Proleev900c28a2021-01-26 19:40:20 +0000118 return std::make_pair(std::move(outputShapes), timing);
119}
120
121nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>
122PreparedModel::executeFenced(const nn::Request& request, const std::vector<nn::SyncFence>& waitFor,
123 nn::MeasureTiming measure, const nn::OptionalTimePoint& deadline,
124 const nn::OptionalDuration& loopTimeoutDuration,
125 const nn::OptionalDuration& timeoutDurationAfterFence) const {
126 // Ensure that request is ready for IPC.
127 std::optional<nn::Request> maybeRequestInShared;
Xusong Wang727a7b22021-03-03 16:20:37 -0800128 hal::utils::RequestRelocation relocation;
129 const nn::Request& requestInShared = NN_TRY(hal::utils::convertRequestFromPointerToShared(
130 &request, &maybeRequestInShared, &relocation));
Lev Proleev900c28a2021-01-26 19:40:20 +0000131
132 const auto aidlRequest = NN_TRY(convert(requestInShared));
133 const auto aidlWaitFor = NN_TRY(convert(waitFor));
134 const auto aidlMeasure = NN_TRY(convert(measure));
135 const auto aidlDeadline = NN_TRY(convert(deadline));
136 const auto aidlLoopTimeoutDuration = NN_TRY(convert(loopTimeoutDuration));
137 const auto aidlTimeoutDurationAfterFence = NN_TRY(convert(timeoutDurationAfterFence));
Xusong Wang727a7b22021-03-03 16:20:37 -0800138 return executeFencedInternal(aidlRequest, aidlWaitFor, aidlMeasure, aidlDeadline,
139 aidlLoopTimeoutDuration, aidlTimeoutDurationAfterFence,
140 relocation);
141}
142
143nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>
144PreparedModel::executeFencedInternal(const Request& request,
145 const std::vector<ndk::ScopedFileDescriptor>& waitFor,
146 bool measure, int64_t deadline, int64_t loopTimeoutDuration,
147 int64_t timeoutDurationAfterFence,
148 const hal::utils::RequestRelocation& relocation) const {
149 if (relocation.input) {
150 relocation.input->flush();
151 }
Lev Proleev900c28a2021-01-26 19:40:20 +0000152
153 FencedExecutionResult result;
Xusong Wang727a7b22021-03-03 16:20:37 -0800154 const auto ret =
155 kPreparedModel->executeFenced(request, waitFor, measure, deadline, loopTimeoutDuration,
156 timeoutDurationAfterFence, &result);
Lev Proleev900c28a2021-01-26 19:40:20 +0000157 HANDLE_ASTATUS(ret) << "executeFenced failed";
158
159 auto resultSyncFence = nn::SyncFence::createAsSignaled();
160 if (result.syncFence.get() != -1) {
161 resultSyncFence = NN_TRY(nn::convert(result.syncFence));
162 }
163
164 auto callback = result.callback;
165 if (callback == nullptr) {
166 return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "callback is null";
167 }
168
169 // If executeFenced required the request memory to be moved into shared memory, block here until
170 // the fenced execution has completed and flush the memory back.
Xusong Wang727a7b22021-03-03 16:20:37 -0800171 if (relocation.output) {
Lev Proleev900c28a2021-01-26 19:40:20 +0000172 const auto state = resultSyncFence.syncWait({});
173 if (state != nn::SyncFence::FenceState::SIGNALED) {
174 return NN_ERROR() << "syncWait failed with " << state;
175 }
Xusong Wang727a7b22021-03-03 16:20:37 -0800176 relocation.output->flush();
Lev Proleev900c28a2021-01-26 19:40:20 +0000177 }
178
179 // Create callback which can be used to retrieve the execution error status and timings.
180 nn::ExecuteFencedInfoCallback resultCallback =
181 [callback]() -> nn::GeneralResult<std::pair<nn::Timing, nn::Timing>> {
182 ErrorStatus errorStatus;
183 Timing timingLaunched;
184 Timing timingFenced;
185 const auto ret = callback->getExecutionInfo(&timingLaunched, &timingFenced, &errorStatus);
186 HANDLE_ASTATUS(ret) << "fenced execution callback getExecutionInfo failed";
187 return convertFencedExecutionResults(errorStatus, timingLaunched, timingFenced);
188 };
189
190 return std::make_pair(std::move(resultSyncFence), std::move(resultCallback));
191}
192
Xusong Wang727a7b22021-03-03 16:20:37 -0800193nn::GeneralResult<nn::SharedExecution> PreparedModel::createReusableExecution(
194 const nn::Request& request, nn::MeasureTiming measure,
195 const nn::OptionalDuration& loopTimeoutDuration) const {
196 // Ensure that request is ready for IPC.
197 std::optional<nn::Request> maybeRequestInShared;
198 hal::utils::RequestRelocation relocation;
199 const nn::Request& requestInShared = NN_TRY(hal::utils::convertRequestFromPointerToShared(
200 &request, &maybeRequestInShared, &relocation));
201
202 auto aidlRequest = NN_TRY(convert(requestInShared));
203 auto aidlMeasure = NN_TRY(convert(measure));
204 auto aidlLoopTimeoutDuration = NN_TRY(convert(loopTimeoutDuration));
205 return Execution::create(shared_from_this(), std::move(aidlRequest), std::move(relocation),
206 aidlMeasure, aidlLoopTimeoutDuration);
207}
208
Lev Proleev900c28a2021-01-26 19:40:20 +0000209nn::GeneralResult<nn::SharedBurst> PreparedModel::configureExecutionBurst() const {
Michael Butler7a9d6092021-03-10 21:57:13 -0800210 std::shared_ptr<IBurst> burst;
211 const auto ret = kPreparedModel->configureExecutionBurst(&burst);
212 HANDLE_ASTATUS(ret) << "configureExecutionBurst failed";
213 return Burst::create(std::move(burst));
Lev Proleev900c28a2021-01-26 19:40:20 +0000214}
215
216std::any PreparedModel::getUnderlyingResource() const {
217 std::shared_ptr<aidl_hal::IPreparedModel> resource = kPreparedModel;
218 return resource;
219}
220
221} // namespace aidl::android::hardware::neuralnetworks::utils