Add QoS types to NNAPI runtime

Bug: 136739795
Bug: 142902514
Bug: 145300530
Test: mma
Change-Id: If3ce646d512b02daa78479aa7c75de99e20def21

1 files changed, 66 insertions, 67 deletions

diff --git a/nn/runtime/test/TestExecution.cpp b/nn/runtime/test/TestExecution.cpp
index 945500ec0..fb4e9d9e8 100644
--- a/nn/runtime/test/TestExecution.cpp
+++ b/nn/runtime/test/TestExecution.cpp
@@ -33,6 +33,7 @@
 #include "NeuralNetworks.h"
 #include "SampleDriver.h"
 #include "TestNeuralNetworksWrapper.h"
+#include "Utils.h"
 #include "ValidateHal.h"
 
 namespace android {
@@ -51,6 +52,7 @@ using WrapperExecution = nn::test_wrapper::Execution;
 using WrapperModel = nn::test_wrapper::Model;
 using WrapperOperandType = nn::test_wrapper::OperandType;
 using WrapperType = nn::test_wrapper::Type;
+using nn::convertToV1_0;
 
 template <typename T>
 using MQDescriptorSync = hardware::MQDescriptorSync<T>;
@@ -72,44 +74,45 @@ class TestPreparedModelLatest : public IPreparedModel {
           mPreparedModelV1_3(V1_3::IPreparedModel::castFrom(preparedModel).withDefault(nullptr)),
           mErrorStatus(errorStatus) {}
 
-    Return<ErrorStatus> execute(const V1_0::Request& request,
-                                const sp<V1_0::IExecutionCallback>& callback) override {
+    Return<V1_0::ErrorStatus> execute(const V1_0::Request& request,
+                                      const sp<V1_0::IExecutionCallback>& callback) override {
         CHECK(mPreparedModelV1_0 != nullptr) << "V1_0 prepared model is nullptr.";
         if (mErrorStatus == ErrorStatus::NONE) {
             return mPreparedModelV1_0->execute(request, callback);
         } else {
-            callback->notify(mErrorStatus);
-            return ErrorStatus::NONE;
+            callback->notify(convertToV1_0(mErrorStatus));
+            return V1_0::ErrorStatus::NONE;
         }
     }
 
-    Return<ErrorStatus> execute_1_2(const V1_0::Request& request, MeasureTiming measure,
-                                    const sp<V1_2::IExecutionCallback>& callback) override {
+    Return<V1_0::ErrorStatus> execute_1_2(const V1_0::Request& request, MeasureTiming measure,
+                                          const sp<V1_2::IExecutionCallback>& callback) override {
         CHECK(mPreparedModelV1_2 != nullptr) << "V1_2 prepared model is nullptr.";
         if (mErrorStatus == ErrorStatus::NONE) {
             return mPreparedModelV1_2->execute_1_2(request, measure, callback);
         } else if (mErrorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
             OutputShape shape = {.dimensions = {1}, .isSufficient = false};
-            callback->notify_1_2(mErrorStatus, {shape}, kBadTiming);
-            return ErrorStatus::NONE;
+            callback->notify_1_2(convertToV1_0(mErrorStatus), {shape}, kBadTiming);
+            return V1_0::ErrorStatus::NONE;
         } else {
-            callback->notify_1_2(mErrorStatus, {}, kBadTiming);
-            return ErrorStatus::NONE;
+            callback->notify_1_2(convertToV1_0(mErrorStatus), {}, kBadTiming);
+            return V1_0::ErrorStatus::NONE;
         }
     }
 
-    Return<ErrorStatus> execute_1_3(const V1_3::Request& request, MeasureTiming measure,
-                                    const sp<V1_2::IExecutionCallback>& callback) override {
+    Return<V1_3::ErrorStatus> execute_1_3(const V1_3::Request& request, MeasureTiming measure,
+                                          const OptionalTimePoint& deadline,
+                                          const sp<V1_3::IExecutionCallback>& callback) override {
         CHECK(mPreparedModelV1_3 != nullptr) << "V1_3 prepared model is nullptr.";
         if (mErrorStatus == ErrorStatus::NONE) {
-            return mPreparedModelV1_3->execute_1_3(request, measure, callback);
+            return mPreparedModelV1_3->execute_1_3(request, measure, deadline, callback);
         } else if (mErrorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
             OutputShape shape = {.dimensions = {1}, .isSufficient = false};
-            callback->notify_1_2(mErrorStatus, {shape}, kBadTiming);
-            return ErrorStatus::NONE;
+            callback->notify_1_3(mErrorStatus, {shape}, kBadTiming);
+            return V1_3::ErrorStatus::NONE;
         } else {
-            callback->notify_1_2(mErrorStatus, {}, kBadTiming);
-            return ErrorStatus::NONE;
+            callback->notify_1_3(mErrorStatus, {}, kBadTiming);
+            return V1_3::ErrorStatus::NONE;
         }
     }
 
@@ -117,28 +120,23 @@ class TestPreparedModelLatest : public IPreparedModel {
                                       executeSynchronously_cb cb) override {
         CHECK(mPreparedModelV1_2 != nullptr) << "V1_2 prepared model is nullptr.";
         if (mErrorStatus == ErrorStatus::NONE) {
-            return mPreparedModelV1_2->executeSynchronously(
-                    request, measure,
-                    [&cb](ErrorStatus error, const hidl_vec<OutputShape>& outputShapes,
-                          const Timing& timing) { cb(error, outputShapes, timing); });
+            return mPreparedModelV1_2->executeSynchronously(request, measure, cb);
         } else if (mErrorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
             OutputShape shape = {.dimensions = {1}, .isSufficient = false};
-            cb(mErrorStatus, {shape}, kBadTiming);
+            cb(convertToV1_0(mErrorStatus), {shape}, kBadTiming);
             return Void();
         } else {
-            cb(mErrorStatus, {}, kBadTiming);
+            cb(convertToV1_0(mErrorStatus), {}, kBadTiming);
             return Void();
         }
     }
 
     Return<void> executeSynchronously_1_3(const V1_3::Request& request, MeasureTiming measure,
+                                          const OptionalTimePoint& deadline,
                                           executeSynchronously_1_3_cb cb) override {
         CHECK(mPreparedModelV1_3 != nullptr) << "V1_3 prepared model is nullptr.";
         if (mErrorStatus == ErrorStatus::NONE) {
-            return mPreparedModelV1_3->executeSynchronously_1_3(
-                    request, measure,
-                    [&cb](ErrorStatus error, const hidl_vec<OutputShape>& outputShapes,
-                          const Timing& timing) { cb(error, outputShapes, timing); });
+            return mPreparedModelV1_3->executeSynchronously_1_3(request, measure, deadline, cb);
         } else if (mErrorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
             OutputShape shape = {.dimensions = {1}, .isSufficient = false};
             cb(mErrorStatus, {shape}, kBadTiming);
@@ -159,7 +157,7 @@ class TestPreparedModelLatest : public IPreparedModel {
             return mPreparedModelV1_2->configureExecutionBurst(callback, requestChannel,
                                                                resultChannel, cb);
         } else {
-            cb(mErrorStatus, nullptr);
+            cb(convertToV1_0(mErrorStatus), nullptr);
             return Void();
         }
     }
@@ -179,13 +177,13 @@ class TestPreparedModel12 : public V1_2::IPreparedModel {
     TestPreparedModel12(sp<V1_0::IPreparedModel> preparedModel, ErrorStatus errorStatus)
         : mLatestPreparedModel(new TestPreparedModelLatest(preparedModel, errorStatus)) {}
 
-    Return<ErrorStatus> execute(const V1_0::Request& request,
-                                const sp<V1_0::IExecutionCallback>& callback) override {
+    Return<V1_0::ErrorStatus> execute(const V1_0::Request& request,
+                                      const sp<V1_0::IExecutionCallback>& callback) override {
         return mLatestPreparedModel->execute(request, callback);
     }
 
-    Return<ErrorStatus> execute_1_2(const V1_0::Request& request, MeasureTiming measure,
-                                    const sp<V1_2::IExecutionCallback>& callback) override {
+    Return<V1_0::ErrorStatus> execute_1_2(const V1_0::Request& request, MeasureTiming measure,
+                                          const sp<V1_2::IExecutionCallback>& callback) override {
         return mLatestPreparedModel->execute_1_2(request, measure, callback);
     }
 
@@ -213,8 +211,8 @@ class TestPreparedModel10 : public V1_0::IPreparedModel {
     TestPreparedModel10(sp<V1_0::IPreparedModel> preparedModel, ErrorStatus errorStatus)
         : mLatestPreparedModel(new TestPreparedModelLatest(preparedModel, errorStatus)) {}
 
-    Return<ErrorStatus> execute(const V1_0::Request& request,
-                                const sp<V1_0::IExecutionCallback>& callback) override {
+    Return<V1_0::ErrorStatus> execute(const V1_0::Request& request,
+                                      const sp<V1_0::IExecutionCallback>& callback) override {
         return mLatestPreparedModel->execute(request, callback);
     }
 
@@ -242,7 +240,7 @@ class TestDriver13 : public SampleDriver {
                 .relaxedFloat32toFloat16PerformanceTensor = kPerf,
                 .operandPerformance =
                         nn::nonExtensionOperandPerformance<nn::HalVersion::V1_3>(kPerf)};
-        _hidl_cb(ErrorStatus::NONE, capabilities);
+        _hidl_cb(V1_3::ErrorStatus::NONE, capabilities);
         return Void();
     }
 
@@ -250,21 +248,21 @@ class TestDriver13 : public SampleDriver {
                                             getSupportedOperations_1_3_cb cb) override {
         if (nn::validateModel(model)) {
             std::vector<bool> supported(model.main.operations.size(), true);
-            cb(ErrorStatus::NONE, supported);
+            cb(V1_3::ErrorStatus::NONE, supported);
         } else {
-            cb(ErrorStatus::INVALID_ARGUMENT, {});
+            cb(V1_3::ErrorStatus::INVALID_ARGUMENT, {});
         }
         return Void();
     }
 
-    Return<ErrorStatus> prepareModel_1_3(
-            const HidlModel& model, ExecutionPreference preference,
-            const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
-            const CacheToken& token,
+    Return<V1_3::ErrorStatus> prepareModel_1_3(
+            const HidlModel& model, ExecutionPreference preference, Priority priority,
+            const OptionalTimePoint& deadline, const hidl_vec<hidl_handle>& modelCache,
+            const hidl_vec<hidl_handle>& dataCache, const CacheToken& token,
             const sp<V1_3::IPreparedModelCallback>& actualCallback) override {
         sp<PreparedModelCallback> localCallback = new PreparedModelCallback;
-        Return<ErrorStatus> prepareModelReturn = SampleDriver::prepareModel_1_3(
-                model, preference, modelCache, dataCache, token, localCallback);
+        Return<V1_3::ErrorStatus> prepareModelReturn = SampleDriver::prepareModel_1_3(
+                model, preference, priority, deadline, modelCache, dataCache, token, localCallback);
         if (!prepareModelReturn.isOkUnchecked()) {
             return prepareModelReturn;
         }
@@ -281,67 +279,69 @@ class TestDriver13 : public SampleDriver {
                     V1_3::IPreparedModel::castFrom(localCallback->getPreparedModel()));
         } else {
             actualCallback->notify_1_3(
-                    ErrorStatus::NONE,
+                    V1_3::ErrorStatus::NONE,
                     new TestPreparedModel13(localCallback->getPreparedModel(), mErrorStatus));
         }
         return prepareModelReturn;
     }
 
-    Return<ErrorStatus> prepareModel_1_2(
+    Return<V1_0::ErrorStatus> prepareModel_1_2(
             const V1_2::Model& model, ExecutionPreference preference,
             const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
             const CacheToken& token,
             const sp<V1_2::IPreparedModelCallback>& actualCallback) override {
         sp<PreparedModelCallback> localCallback = new PreparedModelCallback;
-        Return<ErrorStatus> prepareModelReturn = SampleDriver::prepareModel_1_2(
+        Return<V1_0::ErrorStatus> prepareModelReturn = SampleDriver::prepareModel_1_2(
                 model, preference, modelCache, dataCache, token, localCallback);
         if (!prepareModelReturn.isOkUnchecked()) {
             return prepareModelReturn;
         }
-        if (prepareModelReturn != ErrorStatus::NONE) {
+        if (prepareModelReturn != V1_0::ErrorStatus::NONE) {
             actualCallback->notify_1_2(
-                    localCallback->getStatus(),
+                    convertToV1_0(localCallback->getStatus()),
                     V1_2::IPreparedModel::castFrom(localCallback->getPreparedModel()));
             return prepareModelReturn;
         }
         localCallback->wait();
         if (localCallback->getStatus() != ErrorStatus::NONE) {
             actualCallback->notify_1_2(
-                    localCallback->getStatus(),
+                    convertToV1_0(localCallback->getStatus()),
                     V1_2::IPreparedModel::castFrom(localCallback->getPreparedModel()));
         } else {
             actualCallback->notify_1_2(
-                    ErrorStatus::NONE,
+                    V1_0::ErrorStatus::NONE,
                     new TestPreparedModel12(localCallback->getPreparedModel(), mErrorStatus));
         }
         return prepareModelReturn;
     }
 
-    Return<ErrorStatus> prepareModel_1_1(
+    Return<V1_0::ErrorStatus> prepareModel_1_1(
             const V1_1::Model& model, ExecutionPreference preference,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         sp<PreparedModelCallback> localCallback = new PreparedModelCallback;
-        Return<ErrorStatus> prepareModelReturn =
+        Return<V1_0::ErrorStatus> prepareModelReturn =
                 SampleDriver::prepareModel_1_1(model, preference, localCallback);
         if (!prepareModelReturn.isOkUnchecked()) {
             return prepareModelReturn;
         }
-        if (prepareModelReturn != ErrorStatus::NONE) {
-            actualCallback->notify(localCallback->getStatus(), localCallback->getPreparedModel());
+        if (prepareModelReturn != V1_0::ErrorStatus::NONE) {
+            actualCallback->notify(convertToV1_0(localCallback->getStatus()),
+                                   localCallback->getPreparedModel());
             return prepareModelReturn;
         }
         localCallback->wait();
         if (localCallback->getStatus() != ErrorStatus::NONE) {
-            actualCallback->notify(localCallback->getStatus(), localCallback->getPreparedModel());
+            actualCallback->notify(convertToV1_0(localCallback->getStatus()),
+                                   localCallback->getPreparedModel());
         } else {
             actualCallback->notify(
-                    ErrorStatus::NONE,
+                    V1_0::ErrorStatus::NONE,
                     new TestPreparedModel10(localCallback->getPreparedModel(), mErrorStatus));
         }
         return prepareModelReturn;
     }
 
-    Return<ErrorStatus> prepareModel(
+    Return<V1_0::ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return prepareModel_1_1(nn::convertToV1_1(model), ExecutionPreference::FAST_SINGLE_ANSWER,
@@ -378,7 +378,7 @@ class TestDriver12 : public V1_2::IDevice {
                                         getSupportedOperations_cb _hidl_cb) override {
         return mLatestDriver->getSupportedOperations(model, _hidl_cb);
     }
-    Return<ErrorStatus> prepareModel_1_2(
+    Return<V1_0::ErrorStatus> prepareModel_1_2(
             const V1_2::Model& model, ExecutionPreference preference,
             const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
             const CacheToken& token,
@@ -386,12 +386,12 @@ class TestDriver12 : public V1_2::IDevice {
         return mLatestDriver->prepareModel_1_2(model, preference, modelCache, dataCache, token,
                                                actualCallback);
     }
-    Return<ErrorStatus> prepareModel_1_1(
+    Return<V1_0::ErrorStatus> prepareModel_1_1(
             const V1_1::Model& model, ExecutionPreference preference,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return mLatestDriver->prepareModel_1_1(model, preference, actualCallback);
     }
-    Return<ErrorStatus> prepareModel(
+    Return<V1_0::ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return mLatestDriver->prepareModel(model, actualCallback);
@@ -407,10 +407,9 @@ class TestDriver12 : public V1_2::IDevice {
     Return<void> getNumberOfCacheFilesNeeded(getNumberOfCacheFilesNeeded_cb _hidl_cb) {
         return mLatestDriver->getNumberOfCacheFilesNeeded(_hidl_cb);
     }
-    Return<ErrorStatus> prepareModelFromCache(const hidl_vec<hidl_handle>& modelCache,
-                                              const hidl_vec<hidl_handle>& dataCache,
-                                              const CacheToken& token,
-                                              const sp<V1_2::IPreparedModelCallback>& callback) {
+    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) {
         return mLatestDriver->prepareModelFromCache(modelCache, dataCache, token, callback);
     }
 
@@ -430,7 +429,7 @@ class TestDriver11 : public V1_1::IDevice {
                                             getSupportedOperations_1_1_cb _hidl_cb) override {
         return mLatestDriver->getSupportedOperations_1_1(model, _hidl_cb);
     }
-    Return<ErrorStatus> prepareModel_1_1(
+    Return<V1_0::ErrorStatus> prepareModel_1_1(
             const V1_1::Model& model, ExecutionPreference preference,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return mLatestDriver->prepareModel_1_1(model, preference, actualCallback);
@@ -443,7 +442,7 @@ class TestDriver11 : public V1_1::IDevice {
                                         getSupportedOperations_cb _hidl_cb) override {
         return mLatestDriver->getSupportedOperations(model, _hidl_cb);
     }
-    Return<ErrorStatus> prepareModel(
+    Return<V1_0::ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return mLatestDriver->prepareModel(model, actualCallback);
@@ -465,7 +464,7 @@ class TestDriver10 : public V1_0::IDevice {
                                         getSupportedOperations_cb _hidl_cb) override {
         return mLatestDriver->getSupportedOperations(model, _hidl_cb);
     }
-    Return<ErrorStatus> prepareModel(
+    Return<V1_0::ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
         return mLatestDriver->prepareModel(model, actualCallback);