Wrap the CpuExecutor as a device during compilation step.

Make Device a common interface for abstraction of CPU fallback as
well as the actual driver devices. Modify the compilation steps, mainly
the partitioner, to accommodate the change.

Make all possible compilation outcomes plan-based, even for the CPU
fallback, which is a SIMPLE body running on CPU only.

Add validation for invalid empty model and create validation test.

Add validation for empty device list passed to introspection and control
API and create tests.

Bug: 72506261
Test: NeuralNetworksTest_static
Change-Id: Ic63036716afb8a0156c77e0cf43456e490783deb

1 files changed, 77 insertions, 3 deletions

diff --git a/nn/runtime/test/TestValidation.cpp b/nn/runtime/test/TestValidation.cpp
index 60788034b..f3f557e91 100644
--- a/nn/runtime/test/TestValidation.cpp
+++ b/nn/runtime/test/TestValidation.cpp
@@ -333,7 +333,7 @@ TEST_F(ValidationTestModel, IdentifyInputsAndOutputs) {
     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 0, nullptr),
               ANEURALNETWORKS_UNEXPECTED_NULL);
 
-    ANeuralNetworksModel_finish(mModel);
+    createModel();
     // This should fail, as the model is already finished.
     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 1, &output),
               ANEURALNETWORKS_BAD_STATE);
@@ -343,7 +343,7 @@ TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) {
     EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(nullptr, true),
               ANEURALNETWORKS_UNEXPECTED_NULL);
 
-    ANeuralNetworksModel_finish(mModel);
+    createModel();
     // This should fail, as the model is already finished.
     EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, true),
               ANEURALNETWORKS_BAD_STATE);
@@ -353,10 +353,15 @@ TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) {
 
 TEST_F(ValidationTestModel, Finish) {
     EXPECT_EQ(ANeuralNetworksModel_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
-    EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
+    createModel();
     EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_BAD_STATE);
 }
 
+TEST_F(ValidationTestModel, EmptyModel) {
+    // An empty model is invalid
+    EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_BAD_DATA);
+}
+
 TEST_F(ValidationTestModel, CreateCompilation) {
     ANeuralNetworksCompilation* compilation = nullptr;
     EXPECT_EQ(ANeuralNetworksCompilation_create(nullptr, &compilation),
@@ -379,6 +384,10 @@ TEST_F(ValidationTestModel, CreateCompilationForDevices) {
         EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &device, 1, nullptr),
                   ANEURALNETWORKS_UNEXPECTED_NULL);
 
+        // empty device list
+        EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &device, 0, &compilation),
+                  ANEURALNETWORKS_BAD_DATA);
+
         // duplicate devices in the list.
         ANeuralNetworksDevice* invalidDevices[2] = {device, device};
         EXPECT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, invalidDevices, 2,
@@ -417,6 +426,11 @@ TEST_F(ValidationTestModel, GetSupportedOperationsForDevices) {
                 ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, &device, 1, nullptr),
                 ANEURALNETWORKS_UNEXPECTED_NULL);
 
+        // empty device list
+        EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, &device, 0,
+                                                                        supportedOps),
+                  ANEURALNETWORKS_BAD_DATA);
+
         // duplicate devices in the list.
         ANeuralNetworksDevice* invalidDevices[2] = {device, device};
         EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, invalidDevices, 2,
@@ -801,4 +815,64 @@ TEST_F(ValidationTestCompilationForDevices, Finish) {
     EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_BAD_STATE);
 }
 
+class ValidationTestInvalidCompilation : public ValidationTestModel {
+   protected:
+    virtual void SetUp() override {
+        ValidationTestModel::SetUp();
+
+        // Create a model with an OEM operation
+        uint32_t dimensions[]{1};
+        ANeuralNetworksOperandType OEMTensorType{.type = ANEURALNETWORKS_TENSOR_OEM_BYTE,
+                                                 .dimensionCount = 1,
+                                                 .dimensions = dimensions};
+        EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType),
+                  ANEURALNETWORKS_NO_ERROR);
+        EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType),
+                  ANEURALNETWORKS_NO_ERROR);
+        uint32_t inList[1]{0};
+        uint32_t outList[1]{1};
+        ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_OEM_OPERATION, 1,
+                                                    inList, 1, outList),
+                  ANEURALNETWORKS_NO_ERROR);
+        ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, inList, 1, outList),
+                  ANEURALNETWORKS_NO_ERROR);
+        ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
+
+        // Find a device that cannot handle OEM operation and create compilation on that
+        uint32_t numDevices = 0;
+        EXPECT_EQ(ANeuralNetworks_getDeviceCount(&numDevices), ANEURALNETWORKS_NO_ERROR);
+        for (uint32_t i = 0; i < numDevices; i++) {
+            ANeuralNetworksDevice* device;
+            EXPECT_EQ(ANeuralNetworks_getDevice(i, &device), ANEURALNETWORKS_NO_ERROR);
+            bool supported = false;
+            EXPECT_EQ(ANeuralNetworksModel_getSupportedOperationsForDevices(mModel, &device, 1,
+                                                                            &supported),
+                      ANEURALNETWORKS_NO_ERROR);
+            if (!supported) {
+                ASSERT_EQ(ANeuralNetworksCompilation_createForDevices(mModel, &device, 1,
+                                                                      &mInvalidCompilation),
+                          ANEURALNETWORKS_NO_ERROR);
+                break;
+            }
+        }
+    }
+
+    virtual void TearDown() {
+        ANeuralNetworksCompilation_free(mInvalidCompilation);
+        ValidationTestModel::TearDown();
+    }
+
+    ANeuralNetworksCompilation* mInvalidCompilation = nullptr;
+};
+
+TEST_F(ValidationTestInvalidCompilation, CreateExecutionWithInvalidCompilation) {
+    if (!mInvalidCompilation) {
+        return;
+    }
+    ASSERT_EQ(ANeuralNetworksCompilation_finish(mInvalidCompilation), ANEURALNETWORKS_BAD_DATA);
+    ANeuralNetworksExecution* execution = nullptr;
+    EXPECT_EQ(ANeuralNetworksExecution_create(mInvalidCompilation, &execution),
+              ANEURALNETWORKS_BAD_STATE);
+}
+
 }  // namespace