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 "PreparedModel.h"
18
19 #include "Burst.h"
20 #include "Callbacks.h"
21 #include "Conversions.h"
22 #include "Execution.h"
23 #include "Utils.h"
24
25 #include <android/hardware/neuralnetworks/1.0/IPreparedModel.h>
26 #include <android/hardware/neuralnetworks/1.0/types.h>
27 #include <nnapi/IPreparedModel.h>
28 #include <nnapi/Result.h>
29 #include <nnapi/Types.h>
30 #include <nnapi/hal/CommonUtils.h>
31 #include <nnapi/hal/HandleError.h>
32 #include <nnapi/hal/ProtectCallback.h>
33
34 #include <memory>
35 #include <tuple>
36 #include <utility>
37 #include <vector>
38
39 // See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface
40 // lifetimes across processes and for protecting asynchronous calls across HIDL.
41
42 namespace android::hardware::neuralnetworks::V1_0::utils {
43
create(sp<V1_0::IPreparedModel> preparedModel)44 nn::GeneralResult<std::shared_ptr<const PreparedModel>> PreparedModel::create(
45 sp<V1_0::IPreparedModel> preparedModel) {
46 if (preparedModel == nullptr) {
47 return NN_ERROR() << "V1_0::utils::PreparedModel::create must have non-null preparedModel";
48 }
49
50 auto deathHandler = NN_TRY(hal::utils::DeathHandler::create(preparedModel));
51 return std::make_shared<const PreparedModel>(PrivateConstructorTag{}, std::move(preparedModel),
52 std::move(deathHandler));
53 }
54
PreparedModel(PrivateConstructorTag,sp<V1_0::IPreparedModel> preparedModel,hal::utils::DeathHandler deathHandler)55 PreparedModel::PreparedModel(PrivateConstructorTag /*tag*/, sp<V1_0::IPreparedModel> preparedModel,
56 hal::utils::DeathHandler deathHandler)
57 : kPreparedModel(std::move(preparedModel)), kDeathHandler(std::move(deathHandler)) {}
58
execute(const nn::Request & request,nn::MeasureTiming,const nn::OptionalTimePoint &,const nn::OptionalDuration &) const59 nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> PreparedModel::execute(
60 const nn::Request& request, nn::MeasureTiming /*measure*/,
61 const nn::OptionalTimePoint& /*deadline*/,
62 const nn::OptionalDuration& /*loopTimeoutDuration*/) const {
63 // Ensure that request is ready for IPC.
64 std::optional<nn::Request> maybeRequestInShared;
65 hal::utils::RequestRelocation relocation;
66 const nn::Request& requestInShared =
67 NN_TRY(hal::utils::makeExecutionFailure(hal::utils::convertRequestFromPointerToShared(
68 &request, nn::kDefaultRequestMemoryAlignment, nn::kMinMemoryPadding,
69 &maybeRequestInShared, &relocation)));
70
71 const auto hidlRequest = NN_TRY(hal::utils::makeExecutionFailure(convert(requestInShared)));
72
73 return executeInternal(hidlRequest, relocation);
74 }
75
76 nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>
executeInternal(const V1_0::Request & request,const hal::utils::RequestRelocation & relocation) const77 PreparedModel::executeInternal(const V1_0::Request& request,
78 const hal::utils::RequestRelocation& relocation) const {
79 if (relocation.input) {
80 relocation.input->flush();
81 }
82
83 const auto cb = sp<ExecutionCallback>::make();
84 const auto scoped = kDeathHandler.protectCallback(cb.get());
85
86 const auto ret = kPreparedModel->execute(request, cb);
87 const auto status = HANDLE_TRANSPORT_FAILURE(ret);
88 HANDLE_HAL_STATUS(status) << "execution failed with " << toString(status);
89
90 auto result = NN_TRY(cb->get());
91 if (relocation.output) {
92 relocation.output->flush();
93 }
94 return result;
95 }
96
97 nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>
executeFenced(const nn::Request &,const std::vector<nn::SyncFence> &,nn::MeasureTiming,const nn::OptionalTimePoint &,const nn::OptionalDuration &,const nn::OptionalDuration &) const98 PreparedModel::executeFenced(const nn::Request& /*request*/,
99 const std::vector<nn::SyncFence>& /*waitFor*/,
100 nn::MeasureTiming /*measure*/,
101 const nn::OptionalTimePoint& /*deadline*/,
102 const nn::OptionalDuration& /*loopTimeoutDuration*/,
103 const nn::OptionalDuration& /*timeoutDurationAfterFence*/) const {
104 return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)
105 << "IPreparedModel::executeFenced is not supported on 1.0 HAL service";
106 }
107
createReusableExecution(const nn::Request & request,nn::MeasureTiming,const nn::OptionalDuration &) const108 nn::GeneralResult<nn::SharedExecution> PreparedModel::createReusableExecution(
109 const nn::Request& request, nn::MeasureTiming /*measure*/,
110 const nn::OptionalDuration& /*loopTimeoutDuration*/) const {
111 // Ensure that request is ready for IPC.
112 std::optional<nn::Request> maybeRequestInShared;
113 hal::utils::RequestRelocation relocation;
114 const nn::Request& requestInShared = NN_TRY(hal::utils::convertRequestFromPointerToShared(
115 &request, nn::kDefaultRequestMemoryAlignment, nn::kMinMemoryPadding,
116 &maybeRequestInShared, &relocation));
117
118 auto hidlRequest = NN_TRY(convert(requestInShared));
119 return Execution::create(shared_from_this(), std::move(hidlRequest), std::move(relocation));
120 }
121
configureExecutionBurst() const122 nn::GeneralResult<nn::SharedBurst> PreparedModel::configureExecutionBurst() const {
123 return Burst::create(shared_from_this());
124 }
125
getUnderlyingResource() const126 std::any PreparedModel::getUnderlyingResource() const {
127 sp<V1_0::IPreparedModel> resource = kPreparedModel;
128 return resource;
129 }
130
131 } // namespace android::hardware::neuralnetworks::V1_0::utils
132