Revert "Add HAL version 1.3 and add TENSOR_QUANT8_ASYMM_SIGNED OperandType"

This reverts commit af88effce1b911743d562f5490af2300c54f2349.

Reason for revert: the topic breaks git_qt-dev-plus-aosp

Change-Id: Iddfcffb76af61fb20d749902ddf9c960e211c69d

1 files changed, 31 insertions, 135 deletions

diff --git a/nn/runtime/test/TestExecution.cpp b/nn/runtime/test/TestExecution.cpp
index de5020a3d..e4c8d2168 100644
--- a/nn/runtime/test/TestExecution.cpp
+++ b/nn/runtime/test/TestExecution.cpp
@@ -16,15 +16,6 @@
 
 #undef NDEBUG
 
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cassert>
-#include <memory>
-#include <string>
-#include <tuple>
-#include <vector>
-
 #include "Callbacks.h"
 #include "CompilationBuilder.h"
 #include "HalInterfaces.h"
@@ -35,13 +26,19 @@
 #include "TestNeuralNetworksWrapper.h"
 #include "ValidateHal.h"
 
+#include <algorithm>
+#include <cassert>
+#include <vector>
+
+#include <gtest/gtest.h>
+
 namespace android {
 
 using namespace nn::hal;
 using CompilationBuilder = nn::CompilationBuilder;
 using Device = nn::Device;
 using DeviceManager = nn::DeviceManager;
-using HidlModel = V1_3::Model;
+using HidlModel = V1_2::Model;
 using PreparedModelCallback = nn::PreparedModelCallback;
 using Result = nn::test_wrapper::Result;
 using SampleDriver = nn::sample_driver::SampleDriver;
@@ -151,31 +148,30 @@ class TestPreparedModel10 : public V1_0::IPreparedModel {
 };
 
 // Behaves like SampleDriver, except that it produces wrapped IPreparedModel.
-class TestDriver13 : public SampleDriver {
+class TestDriver12 : public SampleDriver {
    public:
     // Allow dummying up the error status for execution of all models
     // prepared from this driver.  If errorStatus is NONE, then
     // execute behaves normally (and sends back the actual execution
-    // status). Otherwise, don't bother to execute, and just send
+    // status).  Otherwise, don't bother to execute, and just send
     // back errorStatus (as the execution status, not the launch
     // status).
-    TestDriver13(const std::string& name, ErrorStatus errorStatus)
+    TestDriver12(const std::string& name, ErrorStatus errorStatus)
         : SampleDriver(name.c_str()), mErrorStatus(errorStatus) {}
 
-    Return<void> getCapabilities_1_3(getCapabilities_1_3_cb _hidl_cb) override {
+    Return<void> getCapabilities_1_2(getCapabilities_1_2_cb _hidl_cb) override {
         android::nn::initVLogMask();
         const PerformanceInfo kPerf = {.execTime = 0.75f, .powerUsage = 0.75f};
         Capabilities capabilities = {
                 .relaxedFloat32toFloat16PerformanceScalar = kPerf,
                 .relaxedFloat32toFloat16PerformanceTensor = kPerf,
-                .operandPerformance =
-                        nn::nonExtensionOperandPerformance<nn::HalVersion::V1_3>(kPerf)};
+                .operandPerformance = nn::nonExtensionOperandPerformance(kPerf)};
         _hidl_cb(ErrorStatus::NONE, capabilities);
         return Void();
     }
 
-    Return<void> getSupportedOperations_1_3(const HidlModel& model,
-                                            getSupportedOperations_1_3_cb cb) override {
+    Return<void> getSupportedOperations_1_2(const HidlModel& model,
+                                            getSupportedOperations_1_2_cb cb) override {
         if (nn::validateModel(model)) {
             std::vector<bool> supported(model.operations.size(), true);
             cb(ErrorStatus::NONE, supported);
@@ -186,37 +182,8 @@ class TestDriver13 : public SampleDriver {
         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, const sp<IPreparedModelCallback>& actualCallback) override {
-        sp<PreparedModelCallback> localCallback = new PreparedModelCallback;
-        Return<ErrorStatus> prepareModelReturn = SampleDriver::prepareModel_1_3(
-                model, preference, modelCache, dataCache, token, localCallback);
-        if (!prepareModelReturn.isOkUnchecked()) {
-            return prepareModelReturn;
-        }
-        if (prepareModelReturn != ErrorStatus::NONE) {
-            actualCallback->notify_1_2(
-                    localCallback->getStatus(),
-                    V1_2::IPreparedModel::castFrom(localCallback->getPreparedModel()));
-            return prepareModelReturn;
-        }
-        localCallback->wait();
-        if (localCallback->getStatus() != ErrorStatus::NONE) {
-            actualCallback->notify_1_2(
-                    localCallback->getStatus(),
-                    V1_2::IPreparedModel::castFrom(localCallback->getPreparedModel()));
-        } else {
-            actualCallback->notify_1_2(
-                    ErrorStatus::NONE,
-                    new TestPreparedModel12(localCallback->getPreparedModel(), mErrorStatus));
-        }
-        return prepareModelReturn;
-    }
-
     Return<ErrorStatus> prepareModel_1_2(
-            const V1_2::Model& model, ExecutionPreference preference,
+            const HidlModel& model, ExecutionPreference preference,
             const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
             const CacheToken& token, const sp<IPreparedModelCallback>& actualCallback) override {
         sp<PreparedModelCallback> localCallback = new PreparedModelCallback;
@@ -279,127 +246,62 @@ private:
     ErrorStatus mErrorStatus;
 };
 
-// Like TestDriver, but implementing 1.2
-class TestDriver12 : public V1_2::IDevice {
-   public:
-    TestDriver12(const std::string& name, ErrorStatus errorStatus)
-        : mLatestDriver(new TestDriver13(name, errorStatus)) {}
-    Return<void> getCapabilities_1_2(getCapabilities_1_2_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities_1_2(_hidl_cb);
-    }
-    Return<void> getCapabilities_1_1(getCapabilities_1_1_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities_1_1(_hidl_cb);
-    }
-    Return<void> getCapabilities(getCapabilities_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities(_hidl_cb);
-    }
-    Return<void> getSupportedOperations_1_2(const V1_2::Model& model,
-                                            getSupportedOperations_1_2_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations_1_2(model, _hidl_cb);
-    }
-    Return<void> getSupportedOperations_1_1(const V1_1::Model& model,
-                                            getSupportedOperations_1_1_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations_1_1(model, _hidl_cb);
-    }
-    Return<void> getSupportedOperations(const V1_0::Model& model,
-                                        getSupportedOperations_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations(model, _hidl_cb);
-    }
-    Return<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<IPreparedModelCallback>& actualCallback) override {
-        return mLatestDriver->prepareModel_1_2(model, preference, modelCache, dataCache, token,
-                                               actualCallback);
-    }
-    Return<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(
-            const V1_0::Model& model,
-            const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
-        return mLatestDriver->prepareModel(model, actualCallback);
-    }
-    Return<DeviceStatus> getStatus() override { return mLatestDriver->getStatus(); }
-    Return<void> getVersionString(getVersionString_cb _hidl_cb) override {
-        return mLatestDriver->getVersionString(_hidl_cb);
-    }
-    Return<void> getType(getType_cb _hidl_cb) override { return mLatestDriver->getType(_hidl_cb); }
-    Return<void> getSupportedExtensions(getSupportedExtensions_cb _hidl_cb) {
-        return mLatestDriver->getSupportedExtensions(_hidl_cb);
-    }
-    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 mLatestDriver->prepareModelFromCache(modelCache, dataCache, token, callback);
-    }
-
-   private:
-    const sp<V1_3::IDevice> mLatestDriver;
-};
-
 // Like TestDriver, but implementing 1.1
 class TestDriver11 : public V1_1::IDevice {
    public:
     TestDriver11(const std::string& name, ErrorStatus errorStatus)
-        : mLatestDriver(new TestDriver13(name, errorStatus)) {}
+        : m12Driver(new TestDriver12(name, errorStatus)) {}
     Return<void> getCapabilities_1_1(getCapabilities_1_1_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities_1_1(_hidl_cb);
+        return m12Driver->getCapabilities_1_1(_hidl_cb);
     }
     Return<void> getSupportedOperations_1_1(const V1_1::Model& model,
                                             getSupportedOperations_1_1_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations_1_1(model, _hidl_cb);
+        return m12Driver->getSupportedOperations_1_1(model, _hidl_cb);
     }
     Return<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 m12Driver->prepareModel_1_1(model, preference, actualCallback);
     }
-    Return<DeviceStatus> getStatus() override { return mLatestDriver->getStatus(); }
+    Return<DeviceStatus> getStatus() override { return m12Driver->getStatus(); }
     Return<void> getCapabilities(getCapabilities_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities(_hidl_cb);
+        return m12Driver->getCapabilities(_hidl_cb);
     }
     Return<void> getSupportedOperations(const V1_0::Model& model,
                                         getSupportedOperations_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations(model, _hidl_cb);
+        return m12Driver->getSupportedOperations(model, _hidl_cb);
     }
     Return<ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
-        return mLatestDriver->prepareModel(model, actualCallback);
+        return m12Driver->prepareModel(model, actualCallback);
     }
 
    private:
-    const sp<V1_3::IDevice> mLatestDriver;
+    const sp<V1_2::IDevice> m12Driver;
 };
 
 // Like TestDriver, but implementing 1.0
 class TestDriver10 : public V1_0::IDevice {
    public:
     TestDriver10(const std::string& name, ErrorStatus errorStatus)
-        : mLatestDriver(new TestDriver13(name, errorStatus)) {}
+        : m12Driver(new TestDriver12(name, errorStatus)) {}
     Return<void> getCapabilities(getCapabilities_cb _hidl_cb) override {
-        return mLatestDriver->getCapabilities(_hidl_cb);
+        return m12Driver->getCapabilities(_hidl_cb);
     }
     Return<void> getSupportedOperations(const V1_0::Model& model,
                                         getSupportedOperations_cb _hidl_cb) override {
-        return mLatestDriver->getSupportedOperations(model, _hidl_cb);
+        return m12Driver->getSupportedOperations(model, _hidl_cb);
     }
     Return<ErrorStatus> prepareModel(
             const V1_0::Model& model,
             const sp<V1_0::IPreparedModelCallback>& actualCallback) override {
-        return mLatestDriver->prepareModel(model, actualCallback);
+        return m12Driver->prepareModel(model, actualCallback);
     }
-    Return<DeviceStatus> getStatus() override { return mLatestDriver->getStatus(); }
+    Return<DeviceStatus> getStatus() override { return m12Driver->getStatus(); }
 
    private:
-    const sp<V1_3::IDevice> mLatestDriver;
+    const sp<V1_2::IDevice> m12Driver;
 };
 
 // This class adds some simple utilities on top of WrapperCompilation in order
@@ -610,12 +512,6 @@ auto kTestValues = ::testing::Values(
         std::make_tuple(ErrorStatus::INVALID_ARGUMENT, Result::BAD_DATA,
                         /* kUseIntrospectionAPI */ false));
 
-class ExecutionTest13 : public ExecutionTestTemplate<TestDriver13> {};
-TEST_P(ExecutionTest13, Wait) {
-    TestWait();
-}
-INSTANTIATE_TEST_CASE_P(Flavor, ExecutionTest13, kTestValues);
-
 class ExecutionTest12 : public ExecutionTestTemplate<TestDriver12> {};
 TEST_P(ExecutionTest12, Wait) {
     TestWait();
@@ -647,7 +543,7 @@ auto kIntrospectionTestValues = ::testing::Values(
         std::make_tuple(ErrorStatus::INVALID_ARGUMENT, Result::BAD_DATA,
                         /* kUseIntrospectionAPI */ true));
 
-INSTANTIATE_TEST_CASE_P(IntrospectionFlavor, ExecutionTest13, kIntrospectionTestValues);
+INSTANTIATE_TEST_CASE_P(IntrospectionFlavor, ExecutionTest12, kIntrospectionTestValues);
 
 }  // namespace
 }  // namespace android