chore: import upstream snapshot with attribution

tensorflow/lite/tools/delegates/compatibility/nnapi/BUILD

@@ -0,0 +1,87 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+
+# BUILD rules for NNAPI delegate compatibility checking.
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = [
+        "//visibility:public",
+    ],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "nnapi_compatibility_lib",
+    srcs = [
+        "nnapi_compatibility_lib.cc",
+    ],
+    hdrs = [
+        "nnapi_compatibility_lib.h",
+    ],
+    deps = [
+        "//tensorflow/lite:framework_stable",
+        "//tensorflow/lite:minimal_logging",
+        "//tensorflow/lite/core/c:common",
+        "//tensorflow/lite/delegates/nnapi:nnapi_delegate",
+    ],
+)
+
+cc_library(
+    name = "nnapi_delegate_compatibility_checker",
+    srcs = ["nnapi_delegate_compatibility_checker.cc"],
+    hdrs = [
+        "nnapi_delegate_compatibility_checker.h",
+    ],
+    copts = ["-DNNAPI_VERBOSE_VALIDATION"],
+    deps = [
+        "//tensorflow/lite:framework_stable",
+        "//tensorflow/lite/c:common",
+        "//tensorflow/lite/core:cc_api_stable",
+        "//tensorflow/lite/core/kernels:builtin_ops",
+        "//tensorflow/lite/delegates/nnapi:nnapi_delegate",
+        "//tensorflow/lite/nnapi:nnapi_lib",
+        "//tensorflow/lite/tools/delegates/compatibility/common:delegate_compatibility_checker_base",
+        "//tensorflow/lite/tools/delegates/compatibility/common:delegate_compatibility_checker_util",
+        "//tensorflow/lite/tools/delegates/compatibility/common:online_helper_delegate",
+        "//tensorflow/lite/tools/delegates/compatibility/protos:compatibility_result_cc",
+        "//tensorflow/lite/tools/versioning:op_signature",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "nnapi_compatibility_lib_test",
+    srcs = [
+        "nnapi_compatibility_lib_test.cc",
+    ],
+    deps = [
+        ":nnapi_compatibility_lib",
+        "//tensorflow/lite/core/c:c_api_types",
+        "//tensorflow/lite/delegates/nnapi:nnapi_delegate_verbose_validation",
+        "//tensorflow/lite/kernels:test_util",
+        "//tensorflow/lite/schema:schema_fbs",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "nnapi_delegate_compatibility_checker_test",
+    srcs = [
+        "nnapi_delegate_compatibility_checker_test.cc",
+    ],
+    data = [
+        "//tensorflow/lite:testdata/add.bin",
+    ],
+    tags = ["no_oss"],  #TODO(b/276295784): Re-enable when fixed.
+    deps = [
+        ":nnapi_delegate_compatibility_checker",
+        "//tensorflow/core/platform:resource_loader",
+        "//tensorflow/lite:model_builder",
+        "//tensorflow/lite/kernels:test_util",
+        "//tensorflow/lite/schema:schema_fbs",
+        "//tensorflow/lite/tools/delegates/compatibility/protos:compatibility_result_cc",
+        "@com_google_absl//absl/status",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_compatibility_lib.cc

@@ -0,0 +1,74 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_compatibility_lib.h"
+
+#include <cstdint>
+#include <map>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/lite/context_util.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate_kernel.h"
+#include "tensorflow/lite/interpreter.h"
+#include "tensorflow/lite/logger.h"
+#include "tensorflow/lite/minimal_logging.h"
+
+namespace tflite {
+namespace tools {
+
+using ::tflite::delegate::nnapi::NNAPIValidationFailure;
+
+TfLiteStatus CheckCompatibility(
+    TfLiteContext* context, int32_t runtime_feature_level,
+    std::vector<int>* supported_nodes,
+    std::map<int, std::vector<NNAPIValidationFailure>>* failures_by_node) {
+  if (!context) {
+    TFLITE_LOG_PROD_ONCE(TFLITE_LOG_ERROR, "Context is nullptr.");
+    return kTfLiteError;
+  }
+  // Gets execution plan.
+  TfLiteIntArray* execution_plan;
+  TF_LITE_ENSURE_STATUS(context->GetExecutionPlan(context, &execution_plan));
+
+  // Validates compatibility for each node.
+  for (int node_index : TfLiteIntArrayView(execution_plan)) {
+    TFLITE_LOG_PROD(TFLITE_LOG_INFO, "Node index: %d", node_index);
+    TfLiteNode* node;
+    TfLiteRegistration* registration;
+    TF_LITE_ENSURE_STATUS(context->GetNodeAndRegistration(
+        context, node_index, &node, &registration));
+    std::vector<delegate::nnapi::NNAPIValidationFailure> map_failures;
+    if (NNAPIDelegateKernel::Validate(
+            context, registration, runtime_feature_level, node,
+            /* is_accelerator_specified= */ true,
+            /* vendor_plugin= */ nullptr, &map_failures)) {
+      TFLITE_LOG_PROD(TFLITE_LOG_INFO, "Built-in Code: %d",
+                      registration->builtin_code);
+      if (supported_nodes) {
+        supported_nodes->push_back(node_index);
+      }
+    } else {
+      if (failures_by_node) {
+        (*failures_by_node)[node_index] = std::move(map_failures);
+      }
+    }
+  }
+  return kTfLiteOk;
+}
+
+}  // namespace tools
+}  // namespace tflite

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_compatibility_lib.h

@@ -0,0 +1,106 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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 TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_COMPATIBILITY_LIB_H_
+#define TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_COMPATIBILITY_LIB_H_
+
+#include <cstdint>
+#include <map>
+#include <vector>
+
+#include "tensorflow/lite/core/c/common.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate_kernel.h"
+
+// WARNING: this header file is DEPRECATED.
+// See https://developer.android.com/ndk/guides/neuralnetworks/migration-guide.
+
+namespace tflite {
+namespace tools {
+
+// Check if the given TFLite flatbuffer model is compatible with NNAPI delegate.
+// WARNING: This is an experimental API and subject to change.
+TfLiteStatus CheckCompatibility(
+    TfLiteContext* context, int32_t runtime_feature_level,
+    std::vector<int>* supported_nodes,
+    std::map<int, std::vector<tflite::delegate::nnapi::NNAPIValidationFailure>>*
+        failures_by_node);
+
+// This utility delegate is required because some TfLiteContext related
+// functions are forbidden if not calling in delegate.
+// WARNING: This is an experimental class and subject to change.
+class CompatibilityCheckerDelegate : public TfLiteDelegate {
+ public:
+  explicit CompatibilityCheckerDelegate(int32_t runtime_feature_level)
+      : TfLiteDelegate(TfLiteDelegateCreate()),
+        runtime_feature_level_(runtime_feature_level),
+        supported_nodes_(),
+        failures_by_node_() {
+    Prepare = DoPrepare;
+    CopyFromBufferHandle = DoCopyFromBufferHandle;
+    CopyToBufferHandle = DoCopyToBufferHandle;
+    FreeBufferHandle = DoFreeBufferHandle;
+    data_ = &delegate_data_;
+  }
+
+  std::vector<int> GetSupportedNodes() { return supported_nodes_; }
+  std::map<int, std::vector<tflite::delegate::nnapi::NNAPIValidationFailure>>
+  GetFailuresByNode() {
+    return failures_by_node_;
+  }
+
+ protected:
+  static TfLiteStatus DoPrepare(TfLiteContext* context,
+                                TfLiteDelegate* delegate) {
+    auto self = reinterpret_cast<CompatibilityCheckerDelegate*>(delegate);
+    TF_LITE_ENSURE_OK(context,
+                      CheckCompatibility(context, self->runtime_feature_level_,
+                                         &(self->supported_nodes_),
+                                         &(self->failures_by_node_)));
+    return kTfLiteOk;
+  }
+
+  // This function is not expected to be called in this delegate.
+  static TfLiteStatus DoCopyFromBufferHandle(TfLiteContext* context,
+                                             TfLiteDelegate* delegate,
+                                             TfLiteBufferHandle buffer_handle,
+                                             TfLiteTensor* tensor) {
+    return kTfLiteError;
+  }
+
+  // This function is not expected to be called in this delegate.
+  static TfLiteStatus DoCopyToBufferHandle(TfLiteContext* context,
+                                           TfLiteDelegate* delegate,
+                                           TfLiteBufferHandle buffer_handle,
+                                           TfLiteTensor* tensor) {
+    return kTfLiteError;
+  }
+
+  // There is no buffer handle in this delegate.
+  static void DoFreeBufferHandle(TfLiteContext* context,
+                                 TfLiteDelegate* delegate,
+                                 TfLiteBufferHandle* handle) {}
+
+ private:
+  int delegate_data_;
+  int runtime_feature_level_;
+  std::vector<int> supported_nodes_;
+  std::map<int, std::vector<tflite::delegate::nnapi::NNAPIValidationFailure>>
+      failures_by_node_;
+};
+
+}  // namespace tools
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_COMPATIBILITY_LIB_H_

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_compatibility_lib_test.cc

@@ -0,0 +1,92 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_compatibility_lib.h"
+
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "tensorflow/lite/core/c/c_api_types.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate_kernel.h"
+#include "tensorflow/lite/kernels/test_util.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite {
+namespace tools {
+
+namespace {
+
+void CompatibilityCheckerDelegateDelete(TfLiteDelegate* delegate) {
+  delete static_cast<CompatibilityCheckerDelegate*>(delegate);
+}
+
+class AddOpModel : public SingleOpModel {
+ public:
+  AddOpModel(const TensorData& input1, const TensorData& input2,
+             const TensorData& output, ActivationFunctionType activation_type,
+             std::unique_ptr<CompatibilityCheckerDelegate> checker_delegate) {
+    input1_ = AddInput(input1);
+    input2_ = AddInput(input2);
+    output_ = AddOutput(output);
+    SetBuiltinOp(BuiltinOperator_ADD, BuiltinOptions_AddOptions,
+                 CreateAddOptions(builder_, activation_type).Union());
+    SetDelegate(
+        {checker_delegate.release(), CompatibilityCheckerDelegateDelete});
+    // Builds interpreter and applies delegate.
+    BuildInterpreter({GetShape(input1_), GetShape(input2_)});
+  }
+
+ protected:
+  int input1_;
+  int input2_;
+  int output_;
+};
+
+}  // namespace
+
+TEST(NnapiDelegateCompabilityTest, InvalidInput) {
+  EXPECT_EQ(CheckCompatibility(nullptr, 0, nullptr, nullptr), kTfLiteError);
+}
+
+TEST(NnapiDelegateCompabilityTest, CompatibleModel) {
+  auto checker_delegate = std::make_unique<CompatibilityCheckerDelegate>(
+      tflite::delegate::nnapi::kMinSdkVersionForNNAPI13);
+  auto* checker_delegate_ptr = checker_delegate.get();
+  AddOpModel add_op_model({TensorType_FLOAT32, {1, 2, 2, 1}},
+                          {TensorType_FLOAT32, {1, 2, 2, 1}},
+                          {TensorType_FLOAT32, {}}, ActivationFunctionType_NONE,
+                          std::move(checker_delegate));
+  EXPECT_EQ(checker_delegate_ptr->GetSupportedNodes().size(), 1);
+  EXPECT_EQ(checker_delegate_ptr->GetFailuresByNode().size(), 0);
+}
+
+TEST(NnapiDelegateCompabilityTest, IncompatibleModel) {
+  auto checker_delegate = std::make_unique<CompatibilityCheckerDelegate>(
+      tflite::delegate::nnapi::kMinSdkVersionForNNAPI13);
+  auto* checker_delegate_ptr = checker_delegate.get();
+  // No activation function is supported for INT32 tensor type.
+  AddOpModel add_op_model(
+      {TensorType_INT32, {1, 2, 2, 1}}, {TensorType_INT32, {1, 2, 2, 1}},
+      {TensorType_INT32, {}}, ActivationFunctionType_RELU_N1_TO_1,
+      std::move(checker_delegate));
+  EXPECT_EQ(checker_delegate_ptr->GetSupportedNodes().size(), 0);
+  EXPECT_EQ(checker_delegate_ptr->GetFailuresByNode().size(), 1);
+}
+
+}  // namespace tools
+}  // namespace tflite

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_delegate_compatibility_checker.cc

@@ -0,0 +1,278 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_delegate_compatibility_checker.h"
+
+#include <cctype>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
+#include "tensorflow/lite/core/interpreter_builder.h"
+#include "tensorflow/lite/core/kernels/register.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate.h"
+#include "tensorflow/lite/delegates/nnapi/nnapi_delegate_kernel.h"
+#include "tensorflow/lite/interpreter.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/nnapi/NeuralNetworksTypes.h"
+#include "tensorflow/lite/tools/delegates/compatibility/common/delegate_compatibility_checker_util.h"
+#include "tensorflow/lite/tools/delegates/compatibility/common/online_helper_delegate.h"
+#include "tensorflow/lite/tools/delegates/compatibility/protos/compatibility_result.pb.h"
+#include "tensorflow/lite/tools/versioning/op_signature.h"
+
+namespace tflite {
+namespace tools {
+
+namespace {
+
+// Gets canonical feature level enum value from the number. In case the
+// feature level is not between 1 and 8, the default value (8) would be
+// assigned.
+void getCanonicalFeatureLevel(int runtime_feature_level,
+                              int& canonical_feature_level) {
+  switch (runtime_feature_level) {
+    case 1:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_1;
+      break;
+    case 2:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_2;
+      break;
+    case 3:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_3;
+      break;
+    case 4:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_4;
+      break;
+    case 5:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_5;
+      break;
+    case 6:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_6;
+      break;
+    case 7:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_7;
+      break;
+    case 8:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_8;
+      break;
+    default:
+      canonical_feature_level = ANEURALNETWORKS_FEATURE_LEVEL_8;
+  }
+}
+
+// Checks if the input string is a valid feature level. To be a valid feature
+// level, the string passed as a parameter should contain only one digit
+// between 1 and 8.
+absl::Status IsValidFeatureLevelInt(const std::string& s) {
+  if (s.size() == 1 && std::isdigit(s[0]) && s[0] > '0' && s[0] < '9') {
+    return absl::OkStatus();
+  }
+  return absl::InvalidArgumentError("Invalid runtime feature level.");
+}
+
+// Gets the runtime feature level from the configurations and convert its
+// value to an integer.
+absl::Status extractRuntimeFeatureLevel(
+    const std::unordered_map<std::string, std::string>& dcc_configs,
+    int& runtime_feature_level) {
+  std::string str_runtime_feature_level;
+  if (dcc_configs.find("nnapi-runtime_feature_level") == dcc_configs.end()) {
+    for (const auto& dcc_config : dcc_configs) {
+      // If an NNAPI parameter is set, but spelled incorrectly, return an error.
+      if (absl::StrContains(dcc_config.first, "nnapi")) {
+        return absl::InvalidArgumentError(
+            "The correct flag name is 'nnapi-runtime_feature_level");
+      }
+    }
+    // Use default as no NNAPI parameter is set.
+    str_runtime_feature_level =
+        std::to_string(tools::kDefaultRuntimeFeatureLevel);
+  } else {
+    str_runtime_feature_level = dcc_configs.at("nnapi-runtime_feature_level");
+    RETURN_IF_ERROR(IsValidFeatureLevelInt(str_runtime_feature_level));
+  }
+  runtime_feature_level = std::stoi(str_runtime_feature_level);
+  return absl::OkStatus();
+}
+
+// Converts NnapiValidationFailureType to compatibilityFailureType to store
+// the error in op_result.
+absl::Status convertToCompatibilityFailureType(
+    std::vector<delegate::nnapi::NNAPIValidationFailure> map_failures,
+    proto::OpCompatibilityResult* op_result) {
+  for (const auto& status : map_failures) {
+    auto compatibility_failure = op_result->add_compatibility_failures();
+    compatibility_failure->set_description(status.message);
+    switch (status.type) {
+      case delegate::nnapi::NNAPIValidationFailureType::kUnsupportedOperator:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERATOR);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedAndroidVersion:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_VERSION);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedOperatorVersion:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERATOR_VERSION);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kUnsupportedInputType:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_INPUT_TYPE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kNotRestrictedScaleCompliant:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::
+                DCC_NOT_RESTRICTED_SCALE_COMPLIANT);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kUnsupportedOutputType:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OUTPUT_TYPE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kUnsupportedOperandSize:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERAND_SIZE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedOperandValue:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERAND_VALUE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedHybridOperator:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_HYBRID_OPERATOR);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedQuantizationType:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_QUANTIZATION_TYPE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kMissingRequiredOperand:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_MISSING_REQUIRED_OPERAND);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kUnsupportedOperandRank:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERAND_RANK);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kInputTensorShouldHaveConstantShape:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::
+                DCC_INPUT_TENSOR_SHOULD_HAVE_CONSTANT_SHAPE);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedOperatorVariant:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_UNSUPPORTED_OPERATOR_VARIANT);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::kNoActivationExpected:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_NO_ACTIVATION_EXPECTED);
+        break;
+      case delegate::nnapi::NNAPIValidationFailureType::
+          kUnsupportedQuantizationParameters:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::
+                DCC_UNSUPPORTED_QUANTIZATION_PARAMETERS);
+        break;
+      default:
+        compatibility_failure->set_failure_type(
+            proto::CompatibilityFailureType::DCC_INTERNAL_ERROR);
+        compatibility_failure->set_description(
+            "Unknown validation failure type.");
+    }
+  }
+  return absl::OkStatus();
+}
+
+}  // namespace
+
+absl::Status
+tools::NnapiDelegateCompatibilityChecker::checkOpCompatibilityOnline(
+    TfLiteContext* context, const TfLiteNode* node,
+    const TfLiteRegistration* registration,
+    std::unordered_map<std::string, std::string> dcc_configs,
+    tflite::proto::OpCompatibilityResult* op_result) {
+  std::vector<delegate::nnapi::NNAPIValidationFailure> map_failures;
+  int runtime_feature_level;
+  RETURN_IF_ERROR(
+      extractRuntimeFeatureLevel(dcc_configs, runtime_feature_level));
+  getCanonicalFeatureLevel(runtime_feature_level, runtime_feature_level);
+  if (NNAPIDelegateKernel::Validate(
+          context, registration, runtime_feature_level, node,
+          /* is_accelerator_specified= */ true,
+          /* vendor_plugin= */ nullptr, &map_failures)) {
+    op_result->set_is_supported(true);
+  } else {
+    RETURN_IF_ERROR(convertToCompatibilityFailureType(map_failures, op_result));
+    op_result->set_is_supported(false);
+  }
+  return absl::OkStatus();
+}
+
+std::unordered_map<std::string, std::string>
+tools::NnapiDelegateCompatibilityChecker::getDccConfigurations() {
+  std::unordered_map<std::string, std::string> dcc_configs;
+  dcc_configs["nnapi-runtime_feature_level"] =
+      std::to_string(runtime_feature_level_);
+  return dcc_configs;
+}
+
+absl::Status tools::NnapiDelegateCompatibilityChecker::setDccConfigurations(
+    const std::unordered_map<std::string, std::string>& dcc_configs) {
+  RETURN_IF_ERROR(
+      extractRuntimeFeatureLevel(dcc_configs, runtime_feature_level_));
+  return absl::OkStatus();
+}
+
+absl::Status
+tools::NnapiDelegateCompatibilityChecker::checkModelCompatibilityOnline(
+    tflite::FlatBufferModel* model_buffer,
+    tflite::proto::CompatibilityResult* result) {
+  std::unique_ptr<tflite::Interpreter> interpreter;
+  tflite::ops::builtin::BuiltinOpResolver resolver;
+  tflite::InterpreterBuilder interpreter_builder(*model_buffer, resolver);
+  auto dcc_configs = getDccConfigurations();
+  std::function<absl::Status(TfLiteContext*, const TfLiteNode*,
+                             const TfLiteRegistration*,
+                             std::unordered_map<std::string, std::string>,
+                             proto::OpCompatibilityResult*)>
+      check_op_func_ptr = &checkOpCompatibilityOnline;
+  OnlineHelperDelegate delegate(dcc_configs, check_op_func_ptr, result);
+  interpreter_builder.AddDelegate(&delegate);
+  interpreter_builder(&interpreter);
+  return absl::OkStatus();
+}
+
+// TODO(b/243489631): Implement the function.
+absl::Status tools::NnapiDelegateCompatibilityChecker::checkOpSigCompatibility(
+    const OpSignature& op_sig,
+    tflite::proto::OpCompatibilityResult* op_result) {
+  return absl::UnimplementedError(
+      "Offline mode is not yet supported on NNAPI delegate compatibility "
+      "checker.");
+}
+
+}  // namespace tools
+}  // namespace tflite

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_delegate_compatibility_checker.h

@@ -0,0 +1,92 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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 TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_DELEGATE_COMPATIBILITY_CHECKER_H_
+#define TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_DELEGATE_COMPATIBILITY_CHECKER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/status/status.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/tools/delegates/compatibility/common/delegate_compatibility_checker_base.h"
+#include "tensorflow/lite/tools/delegates/compatibility/protos/compatibility_result.pb.h"
+#include "tensorflow/lite/tools/versioning/op_signature.h"
+
+// WARNING: this header file is DEPRECATED.
+// See https://developer.android.com/ndk/guides/neuralnetworks/migration-guide.
+
+namespace tflite {
+namespace tools {
+
+// Default runtime feature level used when no parameters are specified.
+inline constexpr int kDefaultRuntimeFeatureLevel = 8;
+
+// Class to check if an operation or a model is compatible with NNAPI delegate.
+// Supported parameters:
+//   - nnapi-runtime_feature_level: Between 1 and 8 (default value: 8)
+class NnapiDelegateCompatibilityChecker
+    : public DelegateCompatibilityCheckerBase {
+ public:
+  NnapiDelegateCompatibilityChecker() {
+    runtime_feature_level_ = kDefaultRuntimeFeatureLevel;
+  }
+
+  absl::Status checkModelCompatibilityOnline(
+      tflite::FlatBufferModel* model_buffer,
+      tflite::proto::CompatibilityResult* result) override;
+
+  // Checks if the node is compatible with the NNAPI delegate using online mode.
+  // Params:
+  //   context: Used to get the tensors. TfLiteTensors can be obtained via
+  //         TfLiteContext, which are used to get tensor type and tensor data,
+  //         the same way as with OpSignature in Offline mode.
+  //   node: Used with context to get the desired tensor, e.g.:
+  //         context->tensors[node->inputs->data[0]]
+  //   registration: Used to get the builtin code and the operator version.
+  //   op_result: Used to store if the node is compatible with the delegate or
+  //              not and why (with a human readable message).
+  static absl::Status checkOpCompatibilityOnline(
+      TfLiteContext* context, const TfLiteNode* node,
+      const TfLiteRegistration* registration,
+      std::unordered_map<std::string, std::string> dcc_configs,
+      tflite::proto::OpCompatibilityResult* op_result);
+
+  // Returns a dictionary with NNAPI delegate specific params.
+  // Keys:
+  //   - nnapi-runtime_feature_level
+  std::unordered_map<std::string, std::string> getDccConfigurations() override;
+
+  // Sets the parameters needed in the specific DCC.
+  // Keys:
+  //   - nnapi-runtime_feature_level
+  absl::Status setDccConfigurations(
+      const std::unordered_map<std::string, std::string>& dcc_configs) override;
+
+ private:
+  absl::Status checkOpSigCompatibility(
+      const OpSignature& op_sig,
+      tflite::proto::OpCompatibilityResult* op_result) override;
+
+  // Runtime feature level
+  // Refer to '/tensorflow/lite/nnapi/NeuralNetworksTypes.h'
+  int runtime_feature_level_;
+};
+
+}  // namespace tools
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_NNAPI_NNAPI_DELEGATE_COMPATIBILITY_CHECKER_H_

tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_delegate_compatibility_checker_test.cc

@@ -0,0 +1,184 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "tensorflow/lite/tools/delegates/compatibility/nnapi/nnapi_delegate_compatibility_checker.h"
+
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "absl/status/status.h"
+#include "tensorflow/core/platform/resource_loader.h"
+#include "tensorflow/lite/kernels/test_util.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+#include "tensorflow/lite/tools/delegates/compatibility/protos/compatibility_result.pb.h"
+
+namespace tflite {
+namespace tools {
+
+#ifndef EXPECT_OK
+#define EXPECT_OK(x) EXPECT_TRUE(x.ok());
+#endif
+
+namespace {
+
+class AddOpModel : public SingleOpModel {
+ public:
+  AddOpModel(const TensorData& input1, const TensorData& input2,
+             const TensorData& output, ActivationFunctionType activation_type) {
+    input1_ = AddInput(input1);
+    input2_ = AddInput(input2);
+    output_ = AddOutput(output);
+    SetBuiltinOp(BuiltinOperator_ADD, BuiltinOptions_AddOptions,
+                 CreateAddOptions(builder_, activation_type).Union());
+    // Builds interpreter.
+    BuildInterpreter({GetShape(input1_), GetShape(input2_)});
+  }
+
+ protected:
+  int input1_;
+  int input2_;
+  int output_;
+};
+
+// Class to test the NNAPI delegate compatibility checker (DCC)
+class NnapiDccTest : public ::testing::Test {
+ protected:
+  void SetUp() override {}
+
+  void TearDown() override { compatibility_result_.Clear(); }
+
+  NnapiDelegateCompatibilityChecker nnapi_dcc_;
+  proto::CompatibilityResult compatibility_result_;
+};
+
+}  // namespace
+
+TEST_F(NnapiDccTest, ValidRuntimeFeatureLevel) {
+  std::unordered_map dcc_configs = nnapi_dcc_.getDccConfigurations();
+  EXPECT_EQ(dcc_configs["nnapi-runtime_feature_level"], "8");
+  EXPECT_OK(nnapi_dcc_.setDccConfigurations(dcc_configs));
+
+  dcc_configs["nnapi-runtime_feature_level"] = "1";
+  EXPECT_OK(nnapi_dcc_.setDccConfigurations(dcc_configs));
+
+  dcc_configs["nnapi-runtime_feature_level"] = "8";
+  EXPECT_OK(nnapi_dcc_.setDccConfigurations(dcc_configs));
+
+  dcc_configs.clear();
+  EXPECT_OK(nnapi_dcc_.setDccConfigurations(dcc_configs));
+  EXPECT_EQ(nnapi_dcc_.getDccConfigurations()["nnapi-runtime_feature_level"],
+            "8");
+}
+
+TEST_F(NnapiDccTest, InvalidRuntimeFeatureLevel) {
+  std::unordered_map dcc_configs = nnapi_dcc_.getDccConfigurations();
+  dcc_configs["nnapi-runtime_feature_level"] = "03";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs["nnapi-runtime_feature_level"] = "a";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs["nnapi-runtime_feature_level"] = "28123497123489123841212344516";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs["nnapi-runtime_feature_level"] = "30.0";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs["nnapi-runtime_feature_level"] = "-30";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs["nnapi-runtime_feature_level"] = "9";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+
+  dcc_configs.clear();
+  dcc_configs["nnapi-runtim_feature_level"] = "8";
+  EXPECT_EQ(nnapi_dcc_.setDccConfigurations(dcc_configs).code(),
+            absl::StatusCode::kInvalidArgument);
+}
+
+TEST_F(NnapiDccTest, CompatibleModelOnlineMode) {
+  const std::string& full_path =
+      tensorflow::GetDataDependencyFilepath("tensorflow/lite/testdata/add.bin");
+  auto fb_model = FlatBufferModel::BuildFromFile(full_path.data());
+  ASSERT_TRUE(fb_model);
+
+  auto model = fb_model->GetModel();
+  EXPECT_EQ(model->subgraphs()->size(), 1);
+  EXPECT_EQ(model->subgraphs()->Get(0)->operators()->size(), 2);
+
+  EXPECT_OK(nnapi_dcc_.checkModelCompatibilityOnline(fb_model.get(),
+                                                     &compatibility_result_));
+  for (auto op_compatibility_result :
+       compatibility_result_.compatibility_results()) {
+    EXPECT_TRUE(op_compatibility_result.is_supported());
+  }
+  EXPECT_EQ(compatibility_result_.compatibility_results_size(), 2);
+}
+
+TEST_F(NnapiDccTest, IncompatibleModelOperation) {
+  // No activation function is supported for INT32 tensor type.
+  AddOpModel add_op_model(
+      {TensorType_INT32, {1, 2, 2, 1}}, {TensorType_INT32, {1, 2, 2, 1}},
+      {TensorType_INT32, {}}, ActivationFunctionType_RELU_N1_TO_1);
+
+  auto fb_model = tflite::FlatBufferModel::BuildFromModel(
+      tflite::GetModel(add_op_model.GetModelBuffer()));
+  ASSERT_TRUE(fb_model);
+
+  EXPECT_OK(nnapi_dcc_.checkModelCompatibilityOnline(fb_model.get(),
+                                                     &compatibility_result_));
+  for (auto op_compatibility_result :
+       compatibility_result_.compatibility_results()) {
+    EXPECT_FALSE(op_compatibility_result.is_supported());
+  }
+  EXPECT_EQ(compatibility_result_.compatibility_results_size(), 1);
+}
+
+TEST_F(NnapiDccTest, IncompatibleModelFeatureLevel) {
+  // INT32 input tensor type is not supported if runtime feature level < 4.
+  AddOpModel add_op_model({TensorType_INT32, {1, 2, 2, 1}},
+                          {TensorType_INT32, {1, 2, 2, 1}},
+                          {TensorType_INT32, {}}, ActivationFunctionType_NONE);
+
+  auto fb_model = tflite::FlatBufferModel::BuildFromModel(
+      tflite::GetModel(add_op_model.GetModelBuffer()));
+  ASSERT_TRUE(fb_model);
+
+  auto nnapi_configs = nnapi_dcc_.getDccConfigurations();
+  nnapi_configs["nnapi-runtime_feature_level"] = "2";
+  EXPECT_OK(nnapi_dcc_.setDccConfigurations(nnapi_configs));
+  EXPECT_OK(nnapi_dcc_.checkModelCompatibilityOnline(fb_model.get(),
+                                                     &compatibility_result_));
+  for (auto op_compatibility_result :
+       compatibility_result_.compatibility_results()) {
+    EXPECT_FALSE(op_compatibility_result.is_supported());
+  }
+  EXPECT_EQ(compatibility_result_.compatibility_results_size(), 1);
+}
+
+}  // namespace tools
+}  // namespace tflite