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

Commit 97e7336c authored by Michael Butler's avatar Michael Butler
Browse files

Create NNAPI adapter interface 

This CL creates Device, PreparedModel, and Buffer classes which adapt a
canonical interface to a NN 1.3 HIDL interface.

Bug: 160668438
Test: mma
Change-Id: Ifee27858efd280307a299b3fe2e1a4bd9240e9de
Merged-In: Ifee27858efd280307a299b3fe2e1a4bd9240e9de
(cherry picked from commit 323dd0c2)
parent 68b6926e

neuralnetworks/utils/adapter/Android.bp

0 → 100644
+37 −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.

//



cc_library_static {

    name: "neuralnetworks_utils_hal_adapter",

    defaults: ["neuralnetworks_utils_defaults"],

    srcs: ["src/*"],

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

    export_include_dirs: ["include"],

    static_libs: [

        "neuralnetworks_types",

        "neuralnetworks_utils_hal_1_0",

        "neuralnetworks_utils_hal_1_1",

        "neuralnetworks_utils_hal_1_2",

        "neuralnetworks_utils_hal_1_3",

    ],

    shared_libs: [

        "android.hardware.neuralnetworks@1.0",

        "android.hardware.neuralnetworks@1.1",

        "android.hardware.neuralnetworks@1.2",

        "android.hardware.neuralnetworks@1.3",

        "libfmq",

    ],

}

neuralnetworks/utils/adapter/include/nnapi/hal/Adapter.h

0 → 100644
+72 −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_UTILS_ADAPTER_ADAPTER_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_ADAPTER_H



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

#include <nnapi/IDevice.h>

#include <nnapi/Types.h>

#include <sys/types.h>

#include <functional>

#include <memory>



// See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface

// lifetimes across processes and for protecting asynchronous calls across HIDL.



namespace android::hardware::neuralnetworks::adapter {



/**

 * A self-contained unit of work to be executed.

 */

using Task = std::function<void()>;



/**

 * A type-erased executor which executes a task asynchronously.

 *

 * This executor is also provided with an Application ID (Android User ID) and an optional deadline

 * for when the caller expects is the upper bound for the amount of time to complete the task.

 */

using Executor = std::function<void(Task, uid_t, nn::OptionalTimePoint)>;



/**

 * Adapt an NNAPI canonical interface object to a HIDL NN HAL interface object.

 *

 * The IPreparedModel object created from IDevice::prepareModel or IDevice::preparedModelFromCache

 * must return "const nn::Model*" from IPreparedModel::getUnderlyingResource().

 *

 * @param device NNAPI canonical IDevice interface object to be adapted.

 * @param executor Type-erased executor to handle executing tasks asynchronously.

 * @return HIDL NN HAL IDevice interface object.

 */

sp<V1_3::IDevice> adapt(nn::SharedDevice device, Executor executor);



/**

 * Adapt an NNAPI canonical interface object to a HIDL NN HAL interface object.

 *

 * The IPreparedModel object created from IDevice::prepareModel or IDevice::preparedModelFromCache

 * must return "const nn::Model*" from IPreparedModel::getUnderlyingResource().

 *

 * This function uses a default executor, which will execute tasks from a detached thread.

 *

 * @param device NNAPI canonical IDevice interface object to be adapted.

 * @return HIDL NN HAL IDevice interface object.

 */

sp<V1_3::IDevice> adapt(nn::SharedDevice device);



}  // namespace android::hardware::neuralnetworks::adapter



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_ADAPTER_H

neuralnetworks/utils/adapter/include/nnapi/hal/Buffer.h

0 → 100644
+46 −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_UTILS_ADAPTER_BUFFER_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_BUFFER_H



#include <android/hardware/neuralnetworks/1.3/IBuffer.h>

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

#include <nnapi/IBuffer.h>

#include <nnapi/Types.h>

#include <memory>



// See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface

// lifetimes across processes and for protecting asynchronous calls across HIDL.



namespace android::hardware::neuralnetworks::adapter {



// Class that adapts nn::IBuffer to V1_3::IBuffer.

class Buffer final : public V1_3::IBuffer {

  public:

    explicit Buffer(nn::SharedBuffer buffer);



    Return<V1_3::ErrorStatus> copyTo(const hidl_memory& dst) override;

    Return<V1_3::ErrorStatus> copyFrom(const hidl_memory& src,

                                       const hidl_vec<uint32_t>& dimensions) override;



  private:

    const nn::SharedBuffer kBuffer;

};



}  // namespace android::hardware::neuralnetworks::adapter



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_BUFFER_H

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

0 → 100644
+96 −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_UTILS_ADAPTER_DEVICE_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_DEVICE_H



#include "nnapi/hal/Adapter.h"



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

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

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

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

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

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

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

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

#include <nnapi/IDevice.h>

#include <nnapi/Types.h>

#include <memory>



// See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface

// lifetimes across processes and for protecting asynchronous calls across HIDL.



namespace android::hardware::neuralnetworks::adapter {



using CacheToken = hidl_array<uint8_t, nn::kByteSizeOfCacheToken>;



// Class that adapts nn::IDevice to V1_3::IDevice.

class Device final : public V1_3::IDevice {

  public:

    Device(nn::SharedDevice device, Executor executor);



    Return<void> getCapabilities(getCapabilities_cb cb) override;

    Return<void> getCapabilities_1_1(getCapabilities_1_1_cb cb) override;

    Return<void> getCapabilities_1_2(getCapabilities_1_2_cb cb) override;

    Return<void> getCapabilities_1_3(getCapabilities_1_3_cb cb) override;

    Return<void> getVersionString(getVersionString_cb cb) override;

    Return<void> getType(getType_cb cb) override;

    Return<void> getSupportedExtensions(getSupportedExtensions_cb) override;

    Return<void> getSupportedOperations(const V1_0::Model& model,

                                        getSupportedOperations_cb cb) override;

    Return<void> getSupportedOperations_1_1(const V1_1::Model& model,

                                            getSupportedOperations_1_1_cb cb) override;

    Return<void> getSupportedOperations_1_2(const V1_2::Model& model,

                                            getSupportedOperations_1_2_cb cb) override;

    Return<void> getSupportedOperations_1_3(const V1_3::Model& model,

                                            getSupportedOperations_1_3_cb cb) override;

    Return<void> getNumberOfCacheFilesNeeded(getNumberOfCacheFilesNeeded_cb cb) override;

    Return<V1_0::ErrorStatus> prepareModel(

            const V1_0::Model& model, const sp<V1_0::IPreparedModelCallback>& callback) override;

    Return<V1_0::ErrorStatus> prepareModel_1_1(

            const V1_1::Model& model, V1_1::ExecutionPreference preference,

            const sp<V1_0::IPreparedModelCallback>& callback) override;

    Return<V1_0::ErrorStatus> prepareModel_1_2(

            const V1_2::Model& model, V1_1::ExecutionPreference preference,

            const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,

            const CacheToken& token, const sp<V1_2::IPreparedModelCallback>& callback) override;

    Return<V1_3::ErrorStatus> prepareModel_1_3(

            const V1_3::Model& model, V1_1::ExecutionPreference preference, V1_3::Priority priority,

            const V1_3::OptionalTimePoint& deadline, const hidl_vec<hidl_handle>& modelCache,

            const hidl_vec<hidl_handle>& dataCache, const CacheToken& token,

            const sp<V1_3::IPreparedModelCallback>& callback) override;

    Return<V1_0::ErrorStatus> prepareModelFromCache(

            const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,

            const CacheToken& token, const sp<V1_2::IPreparedModelCallback>& callback) override;

    Return<V1_3::ErrorStatus> prepareModelFromCache_1_3(

            const V1_3::OptionalTimePoint& deadline, const hidl_vec<hidl_handle>& modelCache,

            const hidl_vec<hidl_handle>& dataCache, const CacheToken& token,

            const sp<V1_3::IPreparedModelCallback>& callback) override;

    Return<V1_0::DeviceStatus> getStatus() override;

    Return<void> allocate(const V1_3::BufferDesc& desc,

                          const hidl_vec<sp<V1_3::IPreparedModel>>& preparedModels,

                          const hidl_vec<V1_3::BufferRole>& inputRoles,

                          const hidl_vec<V1_3::BufferRole>& outputRoles, allocate_cb cb) override;



  private:

    const nn::SharedDevice kDevice;

    const Executor kExecutor;

};



}  // namespace android::hardware::neuralnetworks::adapter



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_DEVICE_H

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

0 → 100644
+79 −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_UTILS_ADAPTER_PREPARED_MODEL_H

#define ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_PREPARED_MODEL_H



#include "nnapi/hal/Adapter.h"



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

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

#include <android/hardware/neuralnetworks/1.2/IBurstCallback.h>

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

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

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

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

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

#include <nnapi/IPreparedModel.h>

#include <nnapi/Types.h>

#include <memory>



// See hardware/interfaces/neuralnetworks/utils/README.md for more information on HIDL interface

// lifetimes across processes and for protecting asynchronous calls across HIDL.



namespace android::hardware::neuralnetworks::adapter {



// Class that adapts nn::IPreparedModel to V1_3::IPreparedModel.

class PreparedModel final : public V1_3::IPreparedModel {

  public:

    PreparedModel(nn::SharedPreparedModel preparedModel, Executor executor, uid_t userId);



    Return<V1_0::ErrorStatus> execute(const V1_0::Request& request,

                                      const sp<V1_0::IExecutionCallback>& callback) override;

    Return<V1_0::ErrorStatus> execute_1_2(const V1_0::Request& request, V1_2::MeasureTiming measure,

                                          const sp<V1_2::IExecutionCallback>& callback) override;

    Return<V1_3::ErrorStatus> execute_1_3(const V1_3::Request& request, V1_2::MeasureTiming measure,

                                          const V1_3::OptionalTimePoint& deadline,

                                          const V1_3::OptionalTimeoutDuration& loopTimeoutDuration,

                                          const sp<V1_3::IExecutionCallback>& callback) override;

    Return<void> executeSynchronously(const V1_0::Request& request, V1_2::MeasureTiming measure,

                                      executeSynchronously_cb cb) override;

    Return<void> executeSynchronously_1_3(const V1_3::Request& request, V1_2::MeasureTiming measure,

                                          const V1_3::OptionalTimePoint& deadline,

                                          const V1_3::OptionalTimeoutDuration& loopTimeoutDuration,

                                          executeSynchronously_1_3_cb cb) override;

    Return<void> configureExecutionBurst(

            const sp<V1_2::IBurstCallback>& callback,

            const MQDescriptorSync<V1_2::FmqRequestDatum>& requestChannel,

            const MQDescriptorSync<V1_2::FmqResultDatum>& resultChannel,

            configureExecutionBurst_cb cb) override;

    Return<void> executeFenced(const V1_3::Request& request, const hidl_vec<hidl_handle>& waitFor,

                               V1_2::MeasureTiming measure, const V1_3::OptionalTimePoint& deadline,

                               const V1_3::OptionalTimeoutDuration& loopTimeoutDuration,

                               const V1_3::OptionalTimeoutDuration& duration,

                               executeFenced_cb callback) override;



    nn::SharedPreparedModel getUnderlyingPreparedModel() const;



  private:

    const nn::SharedPreparedModel kPreparedModel;

    const Executor kExecutor;

    const uid_t kUserId;

};



}  // namespace android::hardware::neuralnetworks::adapter



#endif  // ANDROID_HARDWARE_INTERFACES_NEURALNETWORKS_UTILS_ADAPTER_PREPARED_MODEL_H