chore: import upstream snapshot with attribution

tensorflow/lite/tools/delegates/compatibility/gpu/BUILD

@@ -0,0 +1,48 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = [
+        "//visibility:public",
+    ],
+    licenses = ["notice"],
+)
+
+cc_test(
+    name = "gpu_delegate_compatibility_checker_test",
+    srcs = [
+        "gpu_delegate_compatibility_checker_test.cc",
+    ],
+    data = [
+        "//tensorflow/lite:testdata/add.bin",
+        "//tensorflow/lite:testdata/conv3d_huge_im2col.bin",
+    ],
+    tags = ["no_oss"],  #TODO(b/276295784): Re-enable when fixed.
+    deps = [
+        ":gpu_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",
+    ],
+)
+
+cc_library(
+    name = "gpu_delegate_compatibility_checker",
+    srcs = ["gpu_delegate_compatibility_checker.cc"],
+    hdrs = [
+        "gpu_delegate_compatibility_checker.h",
+    ],
+    deps = [
+        "//tensorflow/lite:model_builder",
+        "//tensorflow/lite/tools/delegates/compatibility/common:delegate_compatibility_checker_base",
+        "//tensorflow/lite/tools/delegates/compatibility/protos:compatibility_result_cc",
+        "//tensorflow/lite/tools/versioning:gpu_compatibility",
+        "//tensorflow/lite/tools/versioning:op_signature",
+        "@com_google_absl//absl/status",
+    ],
+)

tensorflow/lite/tools/delegates/compatibility/gpu/gpu_delegate_compatibility_checker.cc

@@ -0,0 +1,95 @@
+/* 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/gpu/gpu_delegate_compatibility_checker.h"
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/status/status.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/tools/delegates/compatibility/protos/compatibility_result.pb.h"
+#include "tensorflow/lite/tools/versioning/gpu_compatibility.h"
+#include "tensorflow/lite/tools/versioning/op_signature.h"
+
+namespace tflite {
+namespace tools {
+
+namespace {
+
+void convertToValidationFailureType(absl::Status status,
+                                    proto::OpCompatibilityResult* op_result) {
+  auto compatibility_failure = op_result->add_compatibility_failures();
+  compatibility_failure->set_description(std::string(status.message()));
+  switch (status.code()) {
+    case absl::StatusCode::kInvalidArgument:
+      compatibility_failure->set_failure_type(
+          proto::CompatibilityFailureType::DCC_INVALID_ARGUMENT);
+      break;
+    case absl::StatusCode::kUnimplemented:
+      compatibility_failure->set_failure_type(
+          proto::CompatibilityFailureType::DCC_UNIMPLEMENTED_ERROR);
+      break;
+    case absl::StatusCode::kInternal:
+      compatibility_failure->set_failure_type(
+          proto::CompatibilityFailureType::DCC_INTERNAL_ERROR);
+      break;
+    case absl::StatusCode::kOutOfRange:
+      compatibility_failure->set_failure_type(
+          proto::CompatibilityFailureType::DCC_OUT_OF_RANGE);
+      break;
+    default:
+      compatibility_failure->set_failure_type(
+          proto::CompatibilityFailureType::DCC_INTERNAL_ERROR);
+      compatibility_failure->set_description(
+          "Unknown validation failure type.");
+  }
+}
+
+}  // namespace
+
+std::unordered_map<std::string, std::string>
+tools::GpuDelegateCompatibilityChecker::getDccConfigurations() {
+  return {};
+}
+
+absl::Status tools::GpuDelegateCompatibilityChecker::setDccConfigurations(
+    const std::unordered_map<std::string, std::string>& dcc_configs) {
+  return absl::OkStatus();
+}
+
+absl::Status
+tools::GpuDelegateCompatibilityChecker::checkModelCompatibilityOnline(
+    tflite::FlatBufferModel* model_buffer,
+    tflite::proto::CompatibilityResult* result) {
+  return absl::UnimplementedError(
+      "Online mode is not supported on GPU delegate compatibility checker.");
+}
+
+absl::Status tools::GpuDelegateCompatibilityChecker::checkOpSigCompatibility(
+    const OpSignature& op_sig,
+    tflite::proto::OpCompatibilityResult* op_result) {
+  auto status = CheckGpuDelegateCompatibility(op_sig);
+  if (!status.ok()) {
+    convertToValidationFailureType(status, op_result);
+    op_result->set_is_supported(false);
+  } else {
+    op_result->set_is_supported(true);
+  }
+  return absl::OkStatus();
+}
+
+}  // namespace tools
+}  // namespace tflite

tensorflow/lite/tools/delegates/compatibility/gpu/gpu_delegate_compatibility_checker.h

@@ -0,0 +1,59 @@
+/* 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_GPU_GPU_DELEGATE_COMPATIBILITY_CHECKER_H_
+#define TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_GPU_GPU_DELEGATE_COMPATIBILITY_CHECKER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/status/status.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"
+
+namespace tflite {
+namespace tools {
+
+// Class to check if an operation or a model is compatible with GPU delegate.
+// No supported parameters.
+class GpuDelegateCompatibilityChecker
+    : public DelegateCompatibilityCheckerBase {
+ public:
+  GpuDelegateCompatibilityChecker() {}
+
+  // Online mode is not supported in the GPU delegate compatibility checker.
+  absl::Status checkModelCompatibilityOnline(
+      tflite::FlatBufferModel* model_buffer,
+      tflite::proto::CompatibilityResult* result) override;
+
+  // No parameters are supported, no need to call to this function.
+  std::unordered_map<std::string, std::string> getDccConfigurations() override;
+
+  // No parameters are supported, no need to call to this function.
+  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;
+};
+
+}  // namespace tools
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_TOOLS_DELEGATES_COMPATIBILITY_GPU_GPU_DELEGATE_COMPATIBILITY_CHECKER_H_

tensorflow/lite/tools/delegates/compatibility/gpu/gpu_delegate_compatibility_checker_test.cc

@@ -0,0 +1,114 @@
+/* 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/gpu/gpu_delegate_compatibility_checker.h"
+
+#include <string>
+
+#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_;
+};
+
+}  // namespace
+
+TEST(GpuDelegateCompatibilityCheckerTest, CheckOnlineMode) {
+  const std::string& full_path =
+      tensorflow::GetDataDependencyFilepath("tensorflow/lite/testdata/add.bin");
+  auto fb_model = FlatBufferModel::BuildFromFile(full_path.data());
+  ASSERT_TRUE(fb_model);
+
+  proto::CompatibilityResult compatibility_result;
+
+  GpuDelegateCompatibilityChecker gpu_dcc;
+  // Online mode is not supported by GPU DCC
+  EXPECT_EQ(
+      gpu_dcc
+          .checkModelCompatibilityOnline(fb_model.get(), &compatibility_result)
+          .code(),
+      absl::StatusCode::kUnimplemented);
+}
+
+TEST(GpuDelegateCompatibilityCheckerTest, CompatibleModelOfflineMode) {
+  const std::string& full_path =
+      tensorflow::GetDataDependencyFilepath("tensorflow/lite/testdata/add.bin");
+  auto fb_model = FlatBufferModel::BuildFromFile(full_path.data());
+  ASSERT_TRUE(fb_model);
+
+  proto::CompatibilityResult compatibility_result;
+
+  GpuDelegateCompatibilityChecker gpu_dcc;
+  EXPECT_OK(gpu_dcc.checkModelCompatibilityOffline(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(GpuDelegateCompatibilityCheckerTest, IncompatibleModelOfflineMode) {
+  const std::string& full_path = tensorflow::GetDataDependencyFilepath(
+      "tensorflow/lite/testdata/conv3d_huge_im2col.bin");
+
+  auto fb_model = FlatBufferModel::BuildFromFile(full_path.data());
+  ASSERT_TRUE(fb_model);
+
+  proto::CompatibilityResult compatibility_result;
+
+  GpuDelegateCompatibilityChecker gpu_dcc;
+  EXPECT_OK(gpu_dcc.checkModelCompatibilityOffline(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