Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3670c385 authored by Michael Butler's avatar Michael Butler
Browse files

Implement NNAPI canonical interfaces 

This CL implements the canonical IDevice, IPreparedModel, and IBuffer
interfaces for the 1.0, 1.1, 1.2, and 1.3 NN HIDL HAL interfaces.
Further, it introduces "Resilient" adapter interfaces to automatically
retrieve a handle to a recovered interface object after it has died and
rebooted.

This CL also updates the conversion code from returning nn::Result to
nn::GeneralResult, which includes a ErrorStatus code in the case of an
error.

Finally, this CL introduces a new static library
neuralnetworks_utils_hal_service which consists of a single function
::android::nn::hal::getDevices which can be used by the NNAPI runtime to
retrieve the HIDL services without knowing the underlying HIDL types.

Bug: 160668438
Test: mma
Test: NeuralNetworksTest_static
Change-Id: Iec6ae739df196b4034ffb35ea76781fd541ffec3
parent ccf7517d

neuralnetworks/1.0/utils/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ cc_library_static { 
    srcs: ["src/*"],

    local_include_dirs: ["include/nnapi/hal/1.0/"],

    export_include_dirs: ["include"],

    cflags: ["-Wthread-safety"],

    static_libs: [

        "neuralnetworks_types",

        "neuralnetworks_utils_hal_common",

neuralnetworks/1.0/utils/include/nnapi/hal/1.0/Callbacks.h

0 → 100644
+67 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_CALLBACKS_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_CALLBACKS_H



#include <android/hardware/neuralnetworks/1.0/IExecutionCallback.h>

#include <android/hardware/neuralnetworks/1.0/IPreparedModelCallback.h>

#include <android/hardware/neuralnetworks/1.0/types.h>

#include <nnapi/IPreparedModel.h>

#include <nnapi/Result.h>

#include <nnapi/Types.h>

#include <nnapi/hal/CommonUtils.h>

#include <nnapi/hal/ProtectCallback.h>

#include <nnapi/hal/TransferValue.h>



namespace android::hardware::neuralnetworks::V1_0::utils {



class PreparedModelCallback final : public IPreparedModelCallback,

                                    public hal::utils::IProtectedCallback {

  public:

    using Data = nn::GeneralResult<nn::SharedPreparedModel>;



    Return<void> notify(ErrorStatus status, const sp<IPreparedModel>& preparedModel) override;



    void notifyAsDeadObject() override;



    Data get();



  private:

    void notifyInternal(Data result);



    hal::utils::TransferValue<Data> mData;

};



class ExecutionCallback final : public IExecutionCallback, public hal::utils::IProtectedCallback {

  public:

    using Data = nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>>;



    Return<void> notify(ErrorStatus status) override;



    void notifyAsDeadObject() override;



    Data get();



  private:

    void notifyInternal(Data result);



    hal::utils::TransferValue<Data> mData;

};



}  // namespace android::hardware::neuralnetworks::V1_0::utils



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_CALLBACKS_H

neuralnetworks/1.0/utils/include/nnapi/hal/1.0/Conversions.h

+33 −31
Original line number Diff line number Diff line
@@ -24,42 +24,44 @@ 


namespace android::nn {



Result<OperandType> convert(const hal::V1_0::OperandType& operandType);

Result<OperationType> convert(const hal::V1_0::OperationType& operationType);

Result<Operand::LifeTime> convert(const hal::V1_0::OperandLifeTime& lifetime);

Result<DeviceStatus> convert(const hal::V1_0::DeviceStatus& deviceStatus);

Result<Capabilities::PerformanceInfo> convert(const hal::V1_0::PerformanceInfo& performanceInfo);

Result<Capabilities> convert(const hal::V1_0::Capabilities& capabilities);

Result<DataLocation> convert(const hal::V1_0::DataLocation& location);

Result<Operand> convert(const hal::V1_0::Operand& operand);

Result<Operation> convert(const hal::V1_0::Operation& operation);

Result<Model::OperandValues> convert(const hardware::hidl_vec<uint8_t>& operandValues);

Result<Memory> convert(const hardware::hidl_memory& memory);

Result<Model> convert(const hal::V1_0::Model& model);

Result<Request::Argument> convert(const hal::V1_0::RequestArgument& requestArgument);

Result<Request> convert(const hal::V1_0::Request& request);

Result<ErrorStatus> convert(const hal::V1_0::ErrorStatus& status);

GeneralResult<OperandType> convert(const hal::V1_0::OperandType& operandType);

GeneralResult<OperationType> convert(const hal::V1_0::OperationType& operationType);

GeneralResult<Operand::LifeTime> convert(const hal::V1_0::OperandLifeTime& lifetime);

GeneralResult<DeviceStatus> convert(const hal::V1_0::DeviceStatus& deviceStatus);

GeneralResult<Capabilities::PerformanceInfo> convert(

        const hal::V1_0::PerformanceInfo& performanceInfo);

GeneralResult<Capabilities> convert(const hal::V1_0::Capabilities& capabilities);

GeneralResult<DataLocation> convert(const hal::V1_0::DataLocation& location);

GeneralResult<Operand> convert(const hal::V1_0::Operand& operand);

GeneralResult<Operation> convert(const hal::V1_0::Operation& operation);

GeneralResult<Model::OperandValues> convert(const hardware::hidl_vec<uint8_t>& operandValues);

GeneralResult<Memory> convert(const hardware::hidl_memory& memory);

GeneralResult<Model> convert(const hal::V1_0::Model& model);

GeneralResult<Request::Argument> convert(const hal::V1_0::RequestArgument& requestArgument);

GeneralResult<Request> convert(const hal::V1_0::Request& request);

GeneralResult<ErrorStatus> convert(const hal::V1_0::ErrorStatus& status);



}  // namespace android::nn



namespace android::hardware::neuralnetworks::V1_0::utils {



nn::Result<OperandType> convert(const nn::OperandType& operandType);

nn::Result<OperationType> convert(const nn::OperationType& operationType);

nn::Result<OperandLifeTime> convert(const nn::Operand::LifeTime& lifetime);

nn::Result<DeviceStatus> convert(const nn::DeviceStatus& deviceStatus);

nn::Result<PerformanceInfo> convert(const nn::Capabilities::PerformanceInfo& performanceInfo);

nn::Result<Capabilities> convert(const nn::Capabilities& capabilities);

nn::Result<DataLocation> convert(const nn::DataLocation& location);

nn::Result<Operand> convert(const nn::Operand& operand);

nn::Result<Operation> convert(const nn::Operation& operation);

nn::Result<hidl_vec<uint8_t>> convert(const nn::Model::OperandValues& operandValues);

nn::Result<hidl_memory> convert(const nn::Memory& memory);

nn::Result<Model> convert(const nn::Model& model);

nn::Result<RequestArgument> convert(const nn::Request::Argument& requestArgument);

nn::Result<hidl_memory> convert(const nn::Request::MemoryPool& memoryPool);

nn::Result<Request> convert(const nn::Request& request);

nn::Result<ErrorStatus> convert(const nn::ErrorStatus& status);

nn::GeneralResult<OperandType> convert(const nn::OperandType& operandType);

nn::GeneralResult<OperationType> convert(const nn::OperationType& operationType);

nn::GeneralResult<OperandLifeTime> convert(const nn::Operand::LifeTime& lifetime);

nn::GeneralResult<DeviceStatus> convert(const nn::DeviceStatus& deviceStatus);

nn::GeneralResult<PerformanceInfo> convert(

        const nn::Capabilities::PerformanceInfo& performanceInfo);

nn::GeneralResult<Capabilities> convert(const nn::Capabilities& capabilities);

nn::GeneralResult<DataLocation> convert(const nn::DataLocation& location);

nn::GeneralResult<Operand> convert(const nn::Operand& operand);

nn::GeneralResult<Operation> convert(const nn::Operation& operation);

nn::GeneralResult<hidl_vec<uint8_t>> convert(const nn::Model::OperandValues& operandValues);

nn::GeneralResult<hidl_memory> convert(const nn::Memory& memory);

nn::GeneralResult<Model> convert(const nn::Model& model);

nn::GeneralResult<RequestArgument> convert(const nn::Request::Argument& requestArgument);

nn::GeneralResult<hidl_memory> convert(const nn::Request::MemoryPool& memoryPool);

nn::GeneralResult<Request> convert(const nn::Request& request);

nn::GeneralResult<ErrorStatus> convert(const nn::ErrorStatus& status);



}  // namespace android::hardware::neuralnetworks::V1_0::utils

neuralnetworks/1.0/utils/include/nnapi/hal/1.0/Device.h

0 → 100644
+87 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_DEVICE_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_DEVICE_H



#include <android/hardware/neuralnetworks/1.0/IDevice.h>

#include <nnapi/IBuffer.h>

#include <nnapi/IDevice.h>

#include <nnapi/OperandTypes.h>

#include <nnapi/Result.h>

#include <nnapi/Types.h>

#include <nnapi/hal/CommonUtils.h>

#include <nnapi/hal/ProtectCallback.h>



#include <functional>

#include <memory>

#include <optional>

#include <string>

#include <vector>



namespace android::hardware::neuralnetworks::V1_0::utils {



class Device final : public nn::IDevice {

    struct PrivateConstructorTag {};



  public:

    static nn::GeneralResult<std::shared_ptr<const Device>> create(std::string name,

                                                                   sp<V1_0::IDevice> device);



    Device(PrivateConstructorTag tag, std::string name, nn::Capabilities capabilities,

           sp<V1_0::IDevice> device, hal::utils::DeathHandler deathHandler);



    const std::string& getName() const override;

    const std::string& getVersionString() const override;

    nn::Version getFeatureLevel() const override;

    nn::DeviceType getType() const override;

    const std::vector<nn::Extension>& getSupportedExtensions() const override;

    const nn::Capabilities& getCapabilities() const override;

    std::pair<uint32_t, uint32_t> getNumberOfCacheFilesNeeded() const override;



    nn::GeneralResult<void> wait() const override;



    nn::GeneralResult<std::vector<bool>> getSupportedOperations(

            const nn::Model& model) const override;



    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,

            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,

            const nn::CacheToken& token) const override;



    nn::GeneralResult<nn::SharedBuffer> allocate(

            const nn::BufferDesc& desc, const std::vector<nn::SharedPreparedModel>& preparedModels,

            const std::vector<nn::BufferRole>& inputRoles,

            const std::vector<nn::BufferRole>& outputRoles) const override;



  private:

    const std::string kName;

    const std::string kVersionString = "UNKNOWN";

    const std::vector<nn::Extension> kExtensions;

    const nn::Capabilities kCapabilities;

    const sp<V1_0::IDevice> kDevice;

    const hal::utils::DeathHandler kDeathHandler;

};



}  // namespace android::hardware::neuralnetworks::V1_0::utils



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_DEVICE_H

neuralnetworks/1.0/utils/include/nnapi/hal/1.0/PreparedModel.h

0 → 100644
+64 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_PREPARED_MODEL_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_PREPARED_MODEL_H



#include <android/hardware/neuralnetworks/1.0/IPreparedModel.h>

#include <nnapi/IPreparedModel.h>

#include <nnapi/Result.h>

#include <nnapi/Types.h>

#include <nnapi/hal/CommonUtils.h>

#include <nnapi/hal/ProtectCallback.h>



#include <memory>

#include <tuple>

#include <utility>

#include <vector>



namespace android::hardware::neuralnetworks::V1_0::utils {



class PreparedModel final : public nn::IPreparedModel {

    struct PrivateConstructorTag {};



  public:

    static nn::GeneralResult<std::shared_ptr<const PreparedModel>> create(

            sp<V1_0::IPreparedModel> preparedModel);



    PreparedModel(PrivateConstructorTag tag, sp<V1_0::IPreparedModel> preparedModel,

                  hal::utils::DeathHandler deathHandler);



    nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> execute(

            const nn::Request& request, nn::MeasureTiming measure,

            const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration) const override;



    nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>> executeFenced(

            const nn::Request& request, const std::vector<nn::SyncFence>& waitFor,

            nn::MeasureTiming measure, const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration,

            const nn::OptionalTimeoutDuration& timeoutDurationAfterFence) const override;



    std::any getUnderlyingResource() const override;



  private:

    const sp<V1_0::IPreparedModel> kPreparedModel;

    const hal::utils::DeathHandler kDeathHandler;

};



}  // namespace android::hardware::neuralnetworks::V1_0::utils



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_1_0_UTILS_PREPARED_MODEL_H