From ce3e84a8d449cbf31cee57e30f0eef6a96c0ce94 Mon Sep 17 00:00:00 2001 From: telsoa01 Date: Fri, 31 Aug 2018 09:31:35 +0100 Subject: Release 18.08 --- 1.1/ArmnnDriver.hpp | 103 +++++++++++++++++++++++++++++++++ 1.1/ArmnnDriverImpl.cpp | 151 ++++++++++++++++++++++++++++++++++++++++++++++++ 1.1/ArmnnDriverImpl.hpp | 39 +++++++++++++ 3 files changed, 293 insertions(+) create mode 100644 1.1/ArmnnDriver.hpp create mode 100644 1.1/ArmnnDriverImpl.cpp create mode 100644 1.1/ArmnnDriverImpl.hpp (limited to '1.1') diff --git a/1.1/ArmnnDriver.hpp b/1.1/ArmnnDriver.hpp new file mode 100644 index 00000000..6bd8e03c --- /dev/null +++ b/1.1/ArmnnDriver.hpp @@ -0,0 +1,103 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "ArmnnDevice.hpp" +#include "1.0/ArmnnDriverImpl.hpp" +#include "1.1/ArmnnDriverImpl.hpp" + +#include + +namespace armnn_driver { +namespace V1_1 { + +class ArmnnDriver : public ArmnnDevice, public ::android::hardware::neuralnetworks::V1_1::IDevice +{ +public: + ArmnnDriver(DriverOptions options) + : ArmnnDevice(std::move(options)) + { + ALOGV("V1_1::ArmnnDriver::ArmnnDriver()"); + } + ~ArmnnDriver() {} + +public: + Return getCapabilities( + ::android::hardware::neuralnetworks::V1_0::IDevice::getCapabilities_cb cb) + { + ALOGV("V1_1::ArmnnDriver::getCapabilities()"); + + return V1_0::ArmnnDriverImpl::getCapabilities(m_Runtime, cb); + } + + Return getSupportedOperations( + const ::android::hardware::neuralnetworks::V1_0::Model& model, + ::android::hardware::neuralnetworks::V1_0::IDevice::getSupportedOperations_cb cb) + { + ALOGV("V1_1::ArmnnDriver::getSupportedOperations()"); + + return V1_0::ArmnnDriverImpl::getSupportedOperations(m_Runtime, m_Options, model, cb); + } + + Return prepareModel( + const ::android::hardware::neuralnetworks::V1_0::Model& model, + const android::sp& cb) + { + ALOGV("V1_1::ArmnnDriver::prepareModel()"); + + return V1_0::ArmnnDriverImpl::prepareModel(m_Runtime, m_ClTunedParameters, m_Options, model, cb); + } + + Return getCapabilities_1_1( + ::android::hardware::neuralnetworks::V1_1::IDevice::getCapabilities_1_1_cb cb) + { + ALOGV("V1_1::ArmnnDriver::getCapabilities_1_1()"); + + return V1_1::ArmnnDriverImpl::getCapabilities_1_1(m_Runtime, cb); + } + + Return getSupportedOperations_1_1( + const ::android::hardware::neuralnetworks::V1_1::Model& model, + ::android::hardware::neuralnetworks::V1_1::IDevice::getSupportedOperations_1_1_cb cb) + { + ALOGV("V1_1::ArmnnDriver::getSupportedOperations_1_1()"); + + return V1_1::ArmnnDriverImpl::getSupportedOperations_1_1(m_Runtime, m_Options, model, cb); + } + + Return prepareModel_1_1( + const ::android::hardware::neuralnetworks::V1_1::Model& model, + ::android::hardware::neuralnetworks::V1_1::ExecutionPreference preference, + const android::sp& cb) + { + using namespace ::android::hardware::neuralnetworks::V1_0; + + ALOGV("V1_1::ArmnnDriver::prepareModel_1_1()"); + + if(!(preference == ExecutionPreference::LOW_POWER || + preference == ExecutionPreference::FAST_SINGLE_ANSWER || + preference == ExecutionPreference::SUSTAINED_SPEED)) + { + ALOGV("V1_1::ArmnnDriver::prepareModel_1_1(): Invalid execution preference"); + cb->notify(ErrorStatus::INVALID_ARGUMENT, nullptr); + return ErrorStatus::INVALID_ARGUMENT; + } + + return V1_1::ArmnnDriverImpl::prepareModel_1_1(m_Runtime, m_ClTunedParameters, m_Options, model, cb); + } + + Return getStatus() + { + ALOGV("V1_1::ArmnnDriver::getStatus()"); + + return V1_0::ArmnnDriverImpl::getStatus(); + } +}; + +} // armnn_driver::namespace V1_1 +} // namespace armnn_driver diff --git a/1.1/ArmnnDriverImpl.cpp b/1.1/ArmnnDriverImpl.cpp new file mode 100644 index 00000000..a5e32766 --- /dev/null +++ b/1.1/ArmnnDriverImpl.cpp @@ -0,0 +1,151 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "ArmnnDriverImpl.hpp" +#include "../1.0/ArmnnDriverImpl.hpp" + +#include + +#include +#include + +#include + +using namespace std; +using namespace android; +using namespace android::nn; +using namespace android::hardware; + +namespace +{ + +void NotifyCallbackAndCheck(const sp& callback, + ErrorStatus errorStatus, + const sp& preparedModelPtr) +{ + Return returned = callback->notify(errorStatus, preparedModelPtr); + // This check is required, if the callback fails and it isn't checked it will bring down the service + if (!returned.isOk()) + { + ALOGE("V1_1::ArmnnDriverImpl::prepareModel_1_1: hidl callback failed to return properly: %s ", + returned.description().c_str()); + } +} + +Return FailPrepareModel(ErrorStatus error, + const string& message, + const sp& callback) +{ + ALOGW("V1_1::ArmnnDriverImpl::prepareModel_1_1: %s", message.c_str()); + NotifyCallbackAndCheck(callback, error, nullptr); + return error; +} + +} // namespace + +namespace armnn_driver +{ +namespace V1_1 +{ + +Return ArmnnDriverImpl::getCapabilities_1_1( + const armnn::IRuntimePtr& runtime, + neuralnetworks::V1_1::IDevice::getCapabilities_1_1_cb cb) +{ + ALOGV("V1_1::ArmnnDriverImpl::getCapabilities_1_1()"); + + neuralnetworks::V1_0::IDevice::getCapabilities_cb cb_1_0 = + [&](ErrorStatus status, const neuralnetworks::V1_0::Capabilities& capabilities) + { + BOOST_ASSERT_MSG(compliantWithV1_1(capabilities), + "V1_1::ArmnnDriverImpl: V1_0::Capabilities not compliant with V1_1::Capabilities"); + + cb(status, convertToV1_1(capabilities)); + }; + + V1_0::ArmnnDriverImpl::getCapabilities(runtime, cb_1_0); + + return Void(); +} + +Return ArmnnDriverImpl::getSupportedOperations_1_1( + const armnn::IRuntimePtr& runtime, + const DriverOptions& options, + const neuralnetworks::V1_1::Model& model, + neuralnetworks::V1_1::IDevice::getSupportedOperations_1_1_cb cb) +{ + ALOGV("V1_1::ArmnnDriverImpl::getSupportedOperations_1_1()"); + + if(compliantWithV1_0(model)) + { + V1_0::ArmnnDriverImpl::getSupportedOperations(runtime, options, convertToV1_0(model), cb); + } + else + { + std::vector result; + + if (!runtime) + { + ALOGW("V1_1::ArmnnDriverImpl::getSupportedOperations_1_1: Device unavailable"); + cb(ErrorStatus::DEVICE_UNAVAILABLE, result); + return Void(); + } + + if (!android::nn::validateModel(model)) + { + ALOGW("V1_1::ArmnnDriverImpl::getSupportedOperations_1_1: Invalid model passed as input"); + cb(ErrorStatus::INVALID_ARGUMENT, result); + return Void(); + } + + result.assign(model.operations.size(), false); + cb(ErrorStatus::NONE, result); + } + + return Void(); +} + +Return ArmnnDriverImpl::prepareModel_1_1( + const armnn::IRuntimePtr& runtime, + const armnn::IGpuAccTunedParametersPtr& clTunedParameters, + const DriverOptions& options, + const neuralnetworks::V1_1::Model& model, + const sp& cb) +{ + ALOGV("V1_1::ArmnnDriverImpl::prepareModel_1_1()"); + + if(compliantWithV1_0(model)) + { + return V1_0::ArmnnDriverImpl::prepareModel(runtime, clTunedParameters, options, convertToV1_0(model), cb, + model.relaxComputationFloat32toFloat16 && options.GetFp16Enabled()); + } + else + { + if (cb.get() == nullptr) + { + ALOGW("V1_1::ArmnnDriverImpl::prepareModel_1_1: Invalid callback passed to prepareModel"); + return ErrorStatus::INVALID_ARGUMENT; + } + + if (!runtime) + { + return FailPrepareModel(ErrorStatus::DEVICE_UNAVAILABLE, + "V1_1::ArmnnDriverImpl::prepareModel_1_1: Device unavailable", cb); + } + + if (!android::nn::validateModel(model)) + { + return FailPrepareModel(ErrorStatus::INVALID_ARGUMENT, + "V1_1::ArmnnDriverImpl::prepareModel_1_1: Invalid model passed as input", cb); + } + + FailPrepareModel(ErrorStatus::GENERAL_FAILURE, + "V1_1::ArmnnDriverImpl::prepareModel_1_1: Unsupported model", cb); + return ErrorStatus::NONE; + } +} + +} // armnn_driver::namespace V1_1 +} // namespace armnn_driver diff --git a/1.1/ArmnnDriverImpl.hpp b/1.1/ArmnnDriverImpl.hpp new file mode 100644 index 00000000..307d96bf --- /dev/null +++ b/1.1/ArmnnDriverImpl.hpp @@ -0,0 +1,39 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#pragma once + +#include + +#include "DriverOptions.hpp" + +#include + +namespace armnn_driver +{ +namespace V1_1 +{ + +class ArmnnDriverImpl +{ +public: + static Return getCapabilities_1_1( + const armnn::IRuntimePtr& runtime, + ::android::hardware::neuralnetworks::V1_1::IDevice::getCapabilities_1_1_cb cb); + static Return getSupportedOperations_1_1( + const armnn::IRuntimePtr& runtime, + const DriverOptions& options, + const ::android::hardware::neuralnetworks::V1_1::Model& model, + ::android::hardware::neuralnetworks::V1_1::IDevice::getSupportedOperations_1_1_cb cb); + static Return prepareModel_1_1( + const armnn::IRuntimePtr& runtime, + const armnn::IGpuAccTunedParametersPtr& clTunedParameters, + const DriverOptions& options, + const ::android::hardware::neuralnetworks::V1_1::Model& model, + const android::sp& cb); +}; + +} // namespace armnn_driver::V1_1 +} // namespace armnn_driver -- cgit v1.2.1