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

Commit ab1e0ab9 authored by Michael Butler's avatar Michael Butler Committed by Android (Google) Code Review
Browse files

Merge "Implement NNAPI canonical interfaces"

parents a7e50de0 3670c385

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