Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace nn::NativeHandle with nn::SharedHandle

Browse Source 
Bug: 160669116
Test: mma
Change-Id: I73b2b93aab6cbf37d3c145e15ee9ae45228954f1
Merged-In: I73b2b93aab6cbf37d3c145e15ee9ae45228954f1
(cherry picked from commit d4290b8bf8)
This commit is contained in:
Slava Shklyaev
2020-10-27 18:44:01 +00:00
parent d7f04f9f06
commit 49817a0e0f
17 changed files with 135 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
neuralnetworks/1.0/utils/include/nnapi/hal/1.0/Device.h
View File

@@ -59,13 +59,13 @@ class Device final : public nn::IDevice {
nn::GeneralResult<nn::SharedPreparedModel> prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedBuffer> allocate(

6
neuralnetworks/1.0/utils/src/Conversions.cpp
View File

@@ -290,10 +290,8 @@ nn::GeneralResult<hidl_vec<uint8_t>> convert(const nn::Model::OperandValues& ope
}
nn::GeneralResult<hidl_memory> convert(const nn::Memory& memory) {
const auto hidlMemory = hidl_memory(memory.name, memory.handle->handle(), memory.size);
// Copy memory to force the native_handle_t to be copied.
auto copiedMemory = hidlMemory;
return copiedMemory;
return hidl_memory(memory.name, NN_TRY(hal::utils::hidlHandleFromSharedHandle(memory.handle)),
memory.size);
}
nn::GeneralResult<Model> convert(const nn::Model& model) {

8
neuralnetworks/1.0/utils/src/Device.cpp
View File

@@ -157,8 +157,8 @@ nn::GeneralResult<std::vector<bool>> Device::getSupportedOperations(const nn::Mo
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
const nn::Model& model, nn::ExecutionPreference /*preference*/, nn::Priority /*priority*/,
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& /*modelCache*/,
const std::vector<nn::NativeHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& /*modelCache*/,
const std::vector<nn::SharedHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
// Ensure that model is ready for IPC.
std::optional<nn::Model> maybeModelInShared;
const nn::Model& modelInShared =
@@ -181,8 +181,8 @@ nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
}
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModelFromCache(
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& /*modelCache*/,
const std::vector<nn::NativeHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& /*modelCache*/,
const std::vector<nn::SharedHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)
<< "IDevice::prepareModelFromCache not supported on 1.0 HAL service";
}

8
neuralnetworks/1.1/utils/include/nnapi/hal/1.1/Device.h
View File

@@ -59,13 +59,13 @@ class Device final : public nn::IDevice {
nn::GeneralResult<nn::SharedPreparedModel> prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedBuffer> allocate(

8
neuralnetworks/1.1/utils/src/Device.cpp
View File

@@ -159,8 +159,8 @@ nn::GeneralResult<std::vector<bool>> Device::getSupportedOperations(const nn::Mo
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority /*priority*/,
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& /*modelCache*/,
const std::vector<nn::NativeHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& /*modelCache*/,
const std::vector<nn::SharedHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
// Ensure that model is ready for IPC.
std::optional<nn::Model> maybeModelInShared;
const nn::Model& modelInShared =
@@ -184,8 +184,8 @@ nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
}
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModelFromCache(
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& /*modelCache*/,
const std::vector<nn::NativeHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& /*modelCache*/,
const std::vector<nn::SharedHandle>& /*dataCache*/, const nn::CacheToken& /*token*/) const {
return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)
<< "IDevice::prepareModelFromCache not supported on 1.1 HAL service";
}

8
neuralnetworks/1.2/utils/include/nnapi/hal/1.2/Conversions.h
View File

@@ -44,11 +44,11 @@ GeneralResult<Timing> convert(const hal::V1_2::Timing& timing);
GeneralResult<Extension> convert(const hal::V1_2::Extension& extension);
GeneralResult<Extension::OperandTypeInformation> convert(
const hal::V1_2::Extension::OperandTypeInformation& operandTypeInformation);
GeneralResult<NativeHandle> convert(const hardware::hidl_handle& handle);
GeneralResult<SharedHandle> convert(const hardware::hidl_handle& handle);
GeneralResult<std::vector<Extension>> convert(
const hardware::hidl_vec<hal::V1_2::Extension>& extensions);
GeneralResult<std::vector<NativeHandle>> convert(
GeneralResult<std::vector<SharedHandle>> convert(
const hardware::hidl_vec<hardware::hidl_handle>& handles);
GeneralResult<std::vector<OutputShape>> convert(
const hardware::hidl_vec<hal::V1_2::OutputShape>& outputShapes);
@@ -77,10 +77,10 @@ nn::GeneralResult<Timing> convert(const nn::Timing& timing);
nn::GeneralResult<Extension> convert(const nn::Extension& extension);
nn::GeneralResult<Extension::OperandTypeInformation> convert(
const nn::Extension::OperandTypeInformation& operandTypeInformation);
nn::GeneralResult<hidl_handle> convert(const nn::NativeHandle& handle);
nn::GeneralResult<hidl_handle> convert(const nn::SharedHandle& handle);
nn::GeneralResult<hidl_vec<Extension>> convert(const std::vector<nn::Extension>& extensions);
nn::GeneralResult<hidl_vec<hidl_handle>> convert(const std::vector<nn::NativeHandle>& handles);
nn::GeneralResult<hidl_vec<hidl_handle>> convert(const std::vector<nn::SharedHandle>& handles);
nn::GeneralResult<hidl_vec<OutputShape>> convert(const std::vector<nn::OutputShape>& outputShapes);
} // namespace android::hardware::neuralnetworks::V1_2::utils

8
neuralnetworks/1.2/utils/include/nnapi/hal/1.2/Device.h
View File

@@ -68,13 +68,13 @@ class Device final : public nn::IDevice {
nn::GeneralResult<nn::SharedPreparedModel> prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedBuffer> allocate(

16
neuralnetworks/1.2/utils/src/Conversions.cpp
View File

@@ -257,16 +257,15 @@ GeneralResult<Extension::OperandTypeInformation> convert(
};
}
GeneralResult<NativeHandle> convert(const hidl_handle& handle) {
auto* cloned = native_handle_clone(handle.getNativeHandle());
return ::android::NativeHandle::create(cloned, /*ownsHandle=*/true);
GeneralResult<SharedHandle> convert(const hidl_handle& hidlHandle) {
return hal::utils::sharedHandleFromNativeHandle(hidlHandle.getNativeHandle());
}
GeneralResult<std::vector<Extension>> convert(const hidl_vec<hal::V1_2::Extension>& extensions) {
return convertVec(extensions);
}
GeneralResult<std::vector<NativeHandle>> convert(const hidl_vec<hidl_handle>& handles) {
GeneralResult<std::vector<SharedHandle>> convert(const hidl_vec<hidl_handle>& handles) {
return convertVec(handles);
}
@@ -487,18 +486,15 @@ nn::GeneralResult<Extension::OperandTypeInformation> convert(
};
}
nn::GeneralResult<hidl_handle> convert(const nn::NativeHandle& handle) {
const auto hidlHandle = hidl_handle(handle->handle());
// Copy memory to force the native_handle_t to be copied.
auto copiedHandle = hidlHandle;
return copiedHandle;
nn::GeneralResult<hidl_handle> convert(const nn::SharedHandle& handle) {
return hal::utils::hidlHandleFromSharedHandle(handle);
}
nn::GeneralResult<hidl_vec<Extension>> convert(const std::vector<nn::Extension>& extensions) {
return convertVec(extensions);
}
nn::GeneralResult<hidl_vec<hidl_handle>> convert(const std::vector<nn::NativeHandle>& handles) {
nn::GeneralResult<hidl_vec<hidl_handle>> convert(const std::vector<nn::SharedHandle>& handles) {
return convertVec(handles);
}

8
neuralnetworks/1.2/utils/src/Device.cpp
View File

@@ -257,8 +257,8 @@ nn::GeneralResult<std::vector<bool>> Device::getSupportedOperations(const nn::Mo
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority /*priority*/,
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
// Ensure that model is ready for IPC.
std::optional<nn::Model> maybeModelInShared;
const nn::Model& modelInShared =
@@ -286,8 +286,8 @@ nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
}
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModelFromCache(
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint /*deadline*/, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
const auto hidlModelCache = NN_TRY(convert(modelCache));
const auto hidlDataCache = NN_TRY(convert(dataCache));
const auto hidlToken = token;

8
neuralnetworks/1.3/utils/include/nnapi/hal/1.3/Device.h
View File

@@ -61,13 +61,13 @@ class Device final : public nn::IDevice {
nn::GeneralResult<nn::SharedPreparedModel> prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedBuffer> allocate(

8
neuralnetworks/1.3/utils/src/Device.cpp
View File

@@ -179,8 +179,8 @@ nn::GeneralResult<std::vector<bool>> Device::getSupportedOperations(const nn::Mo
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
// Ensure that model is ready for IPC.
std::optional<nn::Model> maybeModelInShared;
const nn::Model& modelInShared =
@@ -211,8 +211,8 @@ nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModel(
}
nn::GeneralResult<nn::SharedPreparedModel> Device::prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
const auto hidlDeadline = NN_TRY(convert(deadline));
const auto hidlModelCache = NN_TRY(V1_2::utils::convert(modelCache));
const auto hidlDataCache = NN_TRY(V1_2::utils::convert(dataCache));

11
neuralnetworks/1.3/utils/src/PreparedModel.cpp
View File

@@ -53,15 +53,6 @@ nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> convert
return hal::utils::makeExecutionFailure(convertExecutionResultsHelper(outputShapes, timing));
}
nn::GeneralResult<hidl_vec<hidl_handle>> convertSyncFences(
const std::vector<nn::SyncFence>& syncFences) {
hidl_vec<hidl_handle> handles(syncFences.size());
for (size_t i = 0; i < syncFences.size(); ++i) {
handles[i] = NN_TRY(V1_2::utils::convert(syncFences[i].getHandle()));
}
return handles;
}
nn::GeneralResult<std::pair<nn::Timing, nn::Timing>> convertFencedExecutionCallbackResults(
const V1_2::Timing& timingLaunched, const V1_2::Timing& timingFenced) {
return std::make_pair(NN_TRY(validatedConvertToCanonical(timingLaunched)),
@@ -221,7 +212,7 @@ PreparedModel::executeFenced(const nn::Request& request, const std::vector<nn::S
NN_TRY(hal::utils::flushDataFromPointerToShared(&request, &maybeRequestInShared));
const auto hidlRequest = NN_TRY(convert(requestInShared));
const auto hidlWaitFor = NN_TRY(convertSyncFences(waitFor));
const auto hidlWaitFor = NN_TRY(hal::utils::convertSyncFences(waitFor));
const auto hidlMeasure = NN_TRY(V1_2::utils::convert(measure));
const auto hidlDeadline = NN_TRY(convert(deadline));
const auto hidlLoopTimeoutDuration = NN_TRY(convert(loopTimeoutDuration));

9
neuralnetworks/utils/common/include/nnapi/hal/CommonUtils.h
View File

@@ -17,6 +17,8 @@
#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_COMMON_COMMON_UTILS_H
#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_COMMON_COMMON_UTILS_H
#include <cutils/native_handle.h>
#include <hidl/HidlSupport.h>
#include <nnapi/Result.h>
#include <nnapi/Types.h>
#include <functional>
@@ -57,6 +59,13 @@ nn::GeneralResult<void> unflushDataFromSharedToPointer(
std::vector<uint32_t> countNumberOfConsumers(size_t numberOfOperands,
const std::vector<nn::Operation>& operations);
nn::GeneralResult<nn::Memory> createSharedMemoryFromHidlMemory(const hidl_memory& memory);
nn::GeneralResult<hidl_handle> hidlHandleFromSharedHandle(const nn::SharedHandle& handle);
nn::GeneralResult<nn::SharedHandle> sharedHandleFromNativeHandle(const native_handle_t* handle);
nn::GeneralResult<hidl_vec<hidl_handle>> convertSyncFences(
const std::vector<nn::SyncFence>& fences);
} // namespace android::hardware::neuralnetworks::utils
#endif // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_COMMON_COMMON_UTILS_H

16
neuralnetworks/utils/common/include/nnapi/hal/ResilientDevice.h
View File

@@ -63,13 +63,13 @@ class ResilientDevice final : public nn::IDevice,
nn::GeneralResult<nn::SharedPreparedModel> prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache,
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache,
const nn::CacheToken& token) const override;
nn::GeneralResult<nn::SharedBuffer> allocate(
@@ -81,12 +81,12 @@ class ResilientDevice final : public nn::IDevice,
nn::GeneralResult<nn::SharedPreparedModel> prepareModelInternal(
bool blocking, const nn::Model& model, nn::ExecutionPreference preference,
nn::Priority priority, nn::OptionalTimePoint deadline,
const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const;
const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const;
nn::GeneralResult<nn::SharedPreparedModel> prepareModelFromCacheInternal(
bool blocking, nn::OptionalTimePoint deadline,
const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const;
const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const;
nn::GeneralResult<nn::SharedBuffer> allocateInternal(
bool blocking, const nn::BufferDesc& desc,
const std::vector<nn::SharedPreparedModel>& preparedModels,

64
neuralnetworks/utils/common/src/CommonUtils.cpp
View File

@@ -19,6 +19,7 @@
#include "HandleError.h"
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <nnapi/Result.h>
#include <nnapi/SharedMemory.h>
#include <nnapi/TypeUtils.h>
@@ -247,4 +248,67 @@ std::vector<uint32_t> countNumberOfConsumers(size_t numberOfOperands,
return nn::countNumberOfConsumers(numberOfOperands, operations);
}
nn::GeneralResult<hidl_handle> hidlHandleFromSharedHandle(const nn::SharedHandle& handle) {
if (handle == nullptr) {
return {};
}
std::vector<base::unique_fd> fds;
fds.reserve(handle->fds.size());
for (const auto& fd : handle->fds) {
int dupFd = dup(fd);
if (dupFd == -1) {
return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to dup the fd";
}
fds.emplace_back(dupFd);
}
native_handle_t* nativeHandle = native_handle_create(handle->fds.size(), handle->ints.size());
if (nativeHandle == nullptr) {
return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to create native_handle";
}
for (size_t i = 0; i < fds.size(); ++i) {
nativeHandle->data[i] = fds[i].release();
}
std::copy(handle->ints.begin(), handle->ints.end(), &nativeHandle->data[nativeHandle->numFds]);
hidl_handle hidlHandle;
hidlHandle.setTo(nativeHandle, /*shouldOwn=*/true);
return hidlHandle;
}
nn::GeneralResult<nn::SharedHandle> sharedHandleFromNativeHandle(const native_handle_t* handle) {
if (handle == nullptr) {
return nullptr;
}
std::vector<base::unique_fd> fds;
fds.reserve(handle->numFds);
for (int i = 0; i < handle->numFds; ++i) {
int dupFd = dup(handle->data[i]);
if (dupFd == -1) {
return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE) << "Failed to dup the fd";
}
fds.emplace_back(dupFd);
}
std::vector<int> ints(&handle->data[handle->numFds],
&handle->data[handle->numFds + handle->numInts]);
return std::make_shared<const nn::Handle>(nn::Handle{
.fds = std::move(fds),
.ints = std::move(ints),
});
}
nn::GeneralResult<hidl_vec<hidl_handle>> convertSyncFences(
const std::vector<nn::SyncFence>& syncFences) {
hidl_vec<hidl_handle> handles(syncFences.size());
for (size_t i = 0; i < syncFences.size(); ++i) {
handles[i] =
NN_TRY(hal::utils::hidlHandleFromSharedHandle(syncFences[i].getSharedHandle()));
}
return handles;
}
} // namespace android::hardware::neuralnetworks::utils

16
neuralnetworks/utils/common/src/ResilientDevice.cpp
View File

@@ -161,8 +161,8 @@ nn::GeneralResult<std::vector<bool>> ResilientDevice::getSupportedOperations(
nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModel(
const nn::Model& model, nn::ExecutionPreference preference, nn::Priority priority,
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
auto self = shared_from_this();
ResilientPreparedModel::Factory makePreparedModel =
[device = std::move(self), model, preference, priority, deadline, modelCache, dataCache,
@@ -174,8 +174,8 @@ nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModel(
}
nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModelFromCache(
nn::OptionalTimePoint deadline, const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
nn::OptionalTimePoint deadline, const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
auto self = shared_from_this();
ResilientPreparedModel::Factory makePreparedModel =
[device = std::move(self), deadline, modelCache, dataCache,
@@ -202,8 +202,8 @@ nn::GeneralResult<nn::SharedBuffer> ResilientDevice::allocate(
nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModelInternal(
bool blocking, const nn::Model& model, nn::ExecutionPreference preference,
nn::Priority priority, nn::OptionalTimePoint deadline,
const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
const auto fn = [&model, preference, priority, deadline, &modelCache, &dataCache,
token](const nn::IDevice& device) {
return device.prepareModel(model, preference, priority, deadline, modelCache, dataCache,
@@ -214,8 +214,8 @@ nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModelInternal
nn::GeneralResult<nn::SharedPreparedModel> ResilientDevice::prepareModelFromCacheInternal(
bool blocking, nn::OptionalTimePoint deadline,
const std::vector<nn::NativeHandle>& modelCache,
const std::vector<nn::NativeHandle>& dataCache, const nn::CacheToken& token) const {
const std::vector<nn::SharedHandle>& modelCache,
const std::vector<nn::SharedHandle>& dataCache, const nn::CacheToken& token) const {
const auto fn = [deadline, &modelCache, &dataCache, token](const nn::IDevice& device) {
return device.prepareModelFromCache(deadline, modelCache, dataCache, token);
};

1
neuralnetworks/utils/service/Android.bp
View File

@@ -26,6 +26,7 @@ cc_library_static {
"neuralnetworks_utils_hal_1_1",
"neuralnetworks_utils_hal_1_2",
"neuralnetworks_utils_hal_1_3",
"neuralnetworks_utils_hal_common",
],
shared_libs: [
"android.hardware.neuralnetworks@1.0",