Implement the following introspection & control APIs:

  - ANeuralNetworksModel_getSupportedOperationsForDevices
  - ANeuralNetworksCompilation_createForDevices

The APIs listed above are added to NDK with corresponding NNAPI runtime
changes. Validation tests and integration tests with mocked CPU driver
are also added. The tests also test APIs to get a device handle and
to query basic information of selected devices.

The changes in DeviceManager are mainly to facilitate testing.

Bug: 112661538
Bug: 112661284
Bug: 111425781
Test: mm
Test: NeuralNetworksTest_static
Change-Id: If7706447ddee993973397765e2eba15845d8bc51

1 files changed, 179 insertions, 15 deletions

diff --git a/nn/runtime/test/TestValidation.cpp b/nn/runtime/test/TestValidation.cpp
index d26f7cf6f..669515608 100644
--- a/nn/runtime/test/TestValidation.cpp
+++ b/nn/runtime/test/TestValidation.cpp
@@ -41,13 +41,8 @@ protected:
         ANeuralNetworksModel_free(mModel);
         ValidationTest::TearDown();
     }
-    ANeuralNetworksModel* mModel = nullptr;
-};
-
-class ValidationTestIdentify : public ValidationTestModel {
-    virtual void SetUp() {
-        ValidationTestModel::SetUp();
 
+    void createModel() {
         uint32_t dimensions[]{1};
         ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32,
                                               .dimensionCount = 1,
@@ -55,6 +50,7 @@ class ValidationTestIdentify : public ValidationTestModel {
         ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
                                               .dimensionCount = 0,
                                               .dimensions = nullptr};
+
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR);
@@ -64,14 +60,17 @@ class ValidationTestIdentify : public ValidationTestModel {
         ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1,
                                                     outList),
                   ANEURALNETWORKS_NO_ERROR);
+        ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
+                  ANEURALNETWORKS_NO_ERROR);
+        ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
+        mNumOperations = 1;
     }
-    virtual void TearDown() {
-        ValidationTestModel::TearDown();
-    }
+
+    uint32_t mNumOperations = 0;
+    ANeuralNetworksModel* mModel = nullptr;
 };
 
-class ValidationTestCompilation : public ValidationTestModel {
-protected:
+class ValidationTestIdentify : public ValidationTestModel {
     virtual void SetUp() {
         ValidationTestModel::SetUp();
 
@@ -82,7 +81,6 @@ protected:
         ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
                                               .dimensionCount = 0,
                                               .dimensions = nullptr};
-
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR);
@@ -92,17 +90,24 @@ protected:
         ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1,
                                                     outList),
                   ANEURALNETWORKS_NO_ERROR);
-        ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
-                  ANEURALNETWORKS_NO_ERROR);
-        ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
+    }
+    virtual void TearDown() { ValidationTestModel::TearDown(); }
+};
 
+class ValidationTestCompilation : public ValidationTestModel {
+   protected:
+    virtual void SetUp() {
+        ValidationTestModel::SetUp();
+        createModel();
         ASSERT_EQ(ANeuralNetworksCompilation_create(mModel, &mCompilation),
                   ANEURALNETWORKS_NO_ERROR);
     }
+
     virtual void TearDown() {
         ANeuralNetworksCompilation_free(mCompilation);
         ValidationTestModel::TearDown();
     }
+
     ANeuralNetworksCompilation* mCompilation = nullptr;
 };
 
@@ -360,6 +365,92 @@ TEST_F(ValidationTestModel, CreateCompilation) {
     EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, &compilation), ANEURALNETWORKS_BAD_STATE);
 }
 
+TEST_F(ValidationTestModel, CreateCompilationForDevices) {
+    createModel();
+    uint32_t numDevices = 0;
+    EXPECT_EQ(ANeuralNetworks_getDeviceCount(&numDevices), ANEURALNETWORKS_NO_ERROR);
+
+    if (numDevices > 0) {
+        ANeuralNetworksDevice* device;
+        EXPECT_EQ(ANeuralNetworks_getDevice(0, &device), ANEURALNETWORKS_NO_ERROR);
+        ANeuralNetworksCompilation* compilation = nullptr;
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(nullptr, &device, 1, &compilation),
+                  ANEURALNETWORKS_UNEXPECTED_NULL);
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &device, 1, nullptr),
+                  ANEURALNETWORKS_UNEXPECTED_NULL);
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &device, 1, &compilation),
+                  ANEURALNETWORKS_BAD_STATE);
+
+        // duplicate devices in the list.
+        ANeuralNetworksDevice* invalidDevices[2] = {device, device};
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, invalidDevices, 2,
+                                                              &compilation),
+                  ANEURALNETWORKS_BAD_DATA);
+        // nullptr in the list.
+        invalidDevices[1] = nullptr;
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, invalidDevices, 2,
+                                                              &compilation),
+                  ANEURALNETWORKS_UNEXPECTED_NULL);
+        // invalid Device pointer in the list.
+        invalidDevices[1] = reinterpret_cast<ANeuralNetworksDevice*>(&numDevices);
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, invalidDevices, 2,
+                                                              &compilation),
+                  ANEURALNETWORKS_BAD_DATA);
+    }
+
+    ANeuralNetworksCompilation* compilation = nullptr;
+    EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(nullptr, nullptr, 1, &compilation),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, nullptr, 1, nullptr),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, nullptr, 1, &compilation),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+}
+
+TEST_F(ValidationTestModel, GetSupportedOperationsForDevices) {
+    createModel();
+    uint32_t numDevices = 0;
+    EXPECT_EQ(ANeuralNetworks_getDeviceCount(&numDevices), ANEURALNETWORKS_NO_ERROR);
+
+    bool supportedOps[20];
+    ASSERT_LE(mNumOperations, sizeof(supportedOps) / sizeof(supportedOps[0]));
+    if (numDevices > 0) {
+        ANeuralNetworksDevice* device;
+        EXPECT_EQ(ANeuralNetworks_getDevice(0, &device), ANEURALNETWORKS_NO_ERROR);
+        EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(nullptr, &device, 1,
+                                                                        supportedOps),
+                  ANEURALNETWORKS_UNEXPECTED_NULL);
+        EXPECT_EQ(
+                ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, &device, 1, nullptr),
+                ANEURALNETWORKS_UNEXPECTED_NULL);
+
+        // duplicate devices in the list.
+        ANeuralNetworksDevice* invalidDevices[2] = {device, device};
+        EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, invalidDevices, 2,
+                                                                        supportedOps),
+                  ANEURALNETWORKS_BAD_DATA);
+        // nullptr in the list.
+        invalidDevices[1] = nullptr;
+        EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, invalidDevices, 2,
+                                                                        supportedOps),
+                  ANEURALNETWORKS_UNEXPECTED_NULL);
+        // invalid Device pointer in the list.
+        invalidDevices[1] = reinterpret_cast<ANeuralNetworksDevice*>(&numDevices);
+        EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, invalidDevices, 2,
+                                                                        supportedOps),
+                  ANEURALNETWORKS_BAD_DATA);
+    }
+
+    EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(nullptr, nullptr, 1,
+                                                                    supportedOps),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, nullptr, 1, nullptr),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    EXPECT_EQ(
+            ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, nullptr, 1, supportedOps),
+            ANEURALNETWORKS_UNEXPECTED_NULL);
+}
+
 TEST_F(ValidationTestIdentify, Ok) {
     uint32_t inList[3]{0, 1, 2};
     uint32_t outList[1]{3};
@@ -402,6 +493,7 @@ TEST_F(ValidationTestIdentify, DuplicateOutputs) {
               ANEURALNETWORKS_BAD_DATA);
 }
 
+// Also see TEST_F(ValidationTestCompilationForDevices, SetPreference)
 TEST_F(ValidationTestCompilation, SetPreference) {
     EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER),
               ANEURALNETWORKS_UNEXPECTED_NULL);
@@ -409,6 +501,7 @@ TEST_F(ValidationTestCompilation, SetPreference) {
     EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA);
 }
 
+// Also see TEST_F(ValidationTestCompilationForDevices, CreateExecution)
 TEST_F(ValidationTestCompilation, CreateExecution) {
     ANeuralNetworksExecution* execution = nullptr;
     EXPECT_EQ(ANeuralNetworksExecution_create(nullptr, &execution),
@@ -419,6 +512,7 @@ TEST_F(ValidationTestCompilation, CreateExecution) {
               ANEURALNETWORKS_BAD_STATE);
 }
 
+// Also see TEST_F(ValidationTestCompilationForDevices, Finish)
 TEST_F(ValidationTestCompilation, Finish) {
     EXPECT_EQ(ANeuralNetworksCompilation_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
     EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR);
@@ -645,4 +739,74 @@ TEST(ValidationTestIntrospection, DeviceGetFeatureLevel) {
     EXPECT_EQ(ANeuralNetworksDevice_getFeatureLevel(nullptr, nullptr),
               ANEURALNETWORKS_UNEXPECTED_NULL);
 }
+
+class ValidationTestCompilationForDevices : public ValidationTestModel {
+   protected:
+    virtual void SetUp() override {
+        ValidationTestModel::SetUp();
+        createModel();
+
+        uint32_t numDevices = 0;
+        EXPECT_EQ(ANeuralNetworks_getDeviceCount(&numDevices), ANEURALNETWORKS_NO_ERROR);
+
+        if (numDevices > 0) {
+            EXPECT_EQ(ANeuralNetworks_getDevice(0, &mDevice), ANEURALNETWORKS_NO_ERROR);
+            bool supported = false;
+            ASSERT_EQ(mNumOperations, static_cast<uint32_t>(1));
+            EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, &mDevice, 1,
+                                                                            &supported),
+                      ANEURALNETWORKS_NO_ERROR);
+            if (supported) {
+                ASSERT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &mDevice, 1,
+                                                                      &mCompilation),
+                          ANEURALNETWORKS_NO_ERROR);
+            }
+        }
+    }
+
+    virtual void TearDown() {
+        ANeuralNetworksCompilation_free(mCompilation);
+        ValidationTestModel::TearDown();
+    }
+
+    ANeuralNetworksDevice* mDevice = nullptr;
+    ANeuralNetworksCompilation* mCompilation = nullptr;
+};
+
+// Also see TEST_F(ValidationTestCompilation, SetPreference)
+TEST_F(ValidationTestCompilationForDevices, SetPreference) {
+    EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    if (!mCompilation) {
+        return;
+    }
+    EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA);
+}
+
+// Also see TEST_F(ValidationTestCompilation, CreateExecution)
+TEST_F(ValidationTestCompilationForDevices, CreateExecution) {
+    ANeuralNetworksExecution* execution = nullptr;
+    EXPECT_EQ(ANeuralNetworksExecution_create(nullptr, &execution),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    if (!mCompilation) {
+        return;
+    }
+    EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, nullptr),
+              ANEURALNETWORKS_UNEXPECTED_NULL);
+    EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_BAD_STATE);
+}
+
+// Also see TEST_F(ValidationTestCompilation, Finish)
+TEST_F(ValidationTestCompilationForDevices, Finish) {
+    EXPECT_EQ(ANeuralNetworksCompilation_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
+    if (!mCompilation) {
+        return;
+    }
+    EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR);
+    EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation,
+                                                       ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER),
+              ANEURALNETWORKS_BAD_STATE);
+    EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_BAD_STATE);
+}
+
 }  // namespace