chore: import upstream snapshot with attribution

tensorflow/lite/delegates/utils/dummy_delegate/BUILD

@@ -0,0 +1,115 @@
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_shell//shell:sh_test.bzl", "sh_test")
+load("//tensorflow/lite:build_def.bzl", "tflite_copts")
+load("//tensorflow/lite/tools/evaluation/tasks:build_def.bzl", "task_linkopts")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = [
+        "//visibility:public",
+    ],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "dummy_delegate",
+    srcs = [
+        "dummy_delegate.cc",
+    ],
+    hdrs = [
+        "dummy_delegate.h",
+    ],
+    deps = [
+        "//tensorflow/lite/c:c_api_types",
+        "//tensorflow/lite/c:common",
+        "//tensorflow/lite/core/c:common",
+        "//tensorflow/lite/delegates/utils:simple_delegate",
+    ],
+)
+
+cc_binary(
+    name = "dummy_external_delegate.so",
+    srcs = [
+        "external_delegate_adaptor.cc",
+    ],
+    defines = ["TFL_EXTERNAL_DELEGATE_COMPILE_LIBRARY"],
+    linkshared = 1,
+    linkstatic = 1,
+    deps = [
+        ":dummy_delegate",
+        "//tensorflow/lite/core/c:common",
+        "//tensorflow/lite/delegates/external:external_delegate_interface",
+        "//tensorflow/lite/tools:command_line_flags",
+        "//tensorflow/lite/tools:logging",
+    ],
+)
+
+#### The following are for using the dummy test delegate in TFLite tooling ####
+cc_library(
+    name = "dummy_delegate_provider",
+    srcs = ["dummy_delegate_provider.cc"],
+    copts = tflite_copts(),
+    deps = [
+        ":dummy_delegate",
+        "//tensorflow/lite/c:c_api_types",
+        "//tensorflow/lite/tools:command_line_flags",
+        "//tensorflow/lite/tools:tool_params",
+        "//tensorflow/lite/tools/delegates:delegate_provider_hdr",
+    ],
+    alwayslink = 1,
+)
+
+cc_binary(
+    name = "benchmark_model_plus_dummy_delegate",
+    copts = tflite_copts(),
+    linkopts = task_linkopts(),
+    deps = [
+        ":dummy_delegate_provider",
+        "//tensorflow/lite/tools/benchmark:benchmark_model_main",
+    ],
+)
+
+cc_binary(
+    name = "inference_diff_plus_dummy_delegate",
+    copts = tflite_copts(),
+    linkopts = task_linkopts(),
+    deps = [
+        ":dummy_delegate_provider",
+        "//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
+        "//tensorflow/lite/tools/evaluation/tasks/inference_diff:run_eval_lib",
+    ],
+)
+
+cc_binary(
+    name = "imagenet_classification_eval_plus_dummy_delegate",
+    copts = tflite_copts(),
+    linkopts = task_linkopts(),
+    deps = [
+        ":dummy_delegate_provider",
+        "//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
+        "//tensorflow/lite/tools/evaluation/tasks/imagenet_image_classification:run_eval_lib",
+    ],
+)
+
+cc_binary(
+    name = "coco_object_detection_eval_plus_dummy_delegate",
+    copts = tflite_copts(),
+    linkopts = task_linkopts(),
+    deps = [
+        ":dummy_delegate_provider",
+        "//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
+        "//tensorflow/lite/tools/evaluation/tasks/coco_object_detection:run_eval_lib",
+    ],
+)
+
+sh_test(
+    name = "external_delegate_test",
+    srcs = ["external_delegate_test.sh"],
+    data = [
+        "//tensorflow/lite/delegates/utils/dummy_delegate:dummy_external_delegate.so",
+        "//tensorflow/lite/tools/benchmark:benchmark_model",
+        "@tflite_mobilenet_float//:mobilenet_v1_1.0_224.tflite",
+    ],
+    visibility = ["//visibility:private"],
+)

tensorflow/lite/delegates/utils/dummy_delegate/README.md

@@ -0,0 +1,164 @@
+When speaking of a TFLite delegate, how to create it and how to reuse existing
+TFLite testing and tooling with the new delegate are two major challenging
+issues. Here, we show a dummy delegate implementation to illustrate our
+recommended approaches to address these issues.
+
+## Delegate Creation
+
+We recommend using
+[SimpleDelegateInterface and SimpleDelegateKernelInterface](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/delegates/utils/simple_delegate.h).
+We believe such APIs will make it easier to create a TFLite delegate. At a high
+level, developers only need to focus on
+
+* Whether a TFLite node in the graph is supported by the delegate or not.
+* Given the set of supported nodes (i.e. a subgraph of the original model
+graph), implement a delegate kernel that executes this set of nodes.
+
+The dummy delegate implementation here is a good starting point to understand
+the ideas above. For more sophisticated examples, refer to [Flex delegate](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/delegates/flex),
+    [Hexagon delegate](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/delegates/hexagon).
+
+## Testing & Tooling
+
+There are currently **two options** to plug in a newly created TFLite delegate
+to reuse existing TFLite kernel tests and tooling:
+
+- Utilize the **[delegate registrar](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/delegates)**
+mechanism
+- Utilize the
+**[external delegate](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/delegates/external)**
+mechanism.
+
+The former approach requires few changes as detailed below. The latter one
+requires even fewer changes and works with pre-built Tensorflow Lite tooling
+binaries. However, it is less explicit and it might be more complicated to set
+up in automated integration tests. Therefore, for better clarity, the
+delegate-registrar approach is slightly preferred here.
+
+We now describe each option above in more details in the following sections.
+
+### Option 1: Utilize Delegate Registrar
+In this approach, create a delegate provider like the
+[`dummy_delegate_provider.cc`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate_provider.cc)
+here, and then add it as an extra dependency when building the binary. Refer
+[here](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/delegates)
+for more delegate provider examples. Now we look at using this provider for
+testing and evaluation.
+
+#### Kernel Tests
+Tests referred here are defined in [tensorflow/lite/kernels](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/kernels).
+They are based on the
+ [test_util library](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/kernels/test_util.h)
+ and the [testing main function stub](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/kernels/test_main.cc).
+
+To plug in the newly created delegate and reuse these tests, simply add the
+created delegate provider as an extra dependency to
+[`test_util_delegate_providers`](https://github.com/tensorflow/tensorflow/blob/f09dc5cf6e7fde978f9891638f529cd52a3c878f/tensorflow/lite/kernels/BUILD#L203)
+and remove others that are not relevant, like the following:
+
+```
+cc_library(
+    name = "tflite_driver_delegate_providers",
+    deps = [
+        # Existing delegate providers that might be still relevant.
+        ":dummy_delegate_provider",
+    ],
+    alwayslink = 1,
+)
+```
+
+Then build a kernel test, and specify the commandline flags defined in the
+delegate provider when executing the test. Take this case as an example,
+
+```
+bazel build -c opt tensorflow/lite/kernels:add_test
+
+# Setting --use_dummy_delegate=true will apply the dummy delegate to the
+# TFLite model graph
+bazel-bin/tensorflow/lite/kernels/add_test --use_dummy_delegate=true
+```
+
+#### Benchmark and Task Evaluation Tools
+
+In TFLite, we have developed
+[model benchmark tool](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/benchmark)
+and
+[evaluation tools](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/evaluation/tasks)
+that already have integrated existing various TFLite delegates. To reuse these
+tools for the new delegate, similar to the kernel testing above, we simply add
+the created delegate provider as an additional dependency when building the
+binary. See rules in the
+[BUILD](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/delegates/utils/BUILD)
+file for details.
+
+Take reusing the TFLite model benchmark tool as an example, after the delegate
+provider is created, define the BUILD rule like the following:
+
+```
+cc_binary(
+    name = "benchmark_model_plus_dummy_delegate",
+    copts = tflite_copts(),
+    linkopts = task_linkopts(),
+    deps = [
+        # Simply add the delegate provider as an extra dep.
+        ":dummy_delegate_provider",
+        "//tensorflow/lite/tools/benchmark:benchmark_model_main",
+    ],
+)
+```
+
+Now build the binary, and specify the commandline flags defined in this new
+delegate provider and others detailed in the benchmark model tool
+[doc](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/tools/benchmark/README.md)
+when running the benchmark tool like the following:
+
+```
+bazel build -c opt tensorflow/lite/delegates/utils/dummy_delegate:benchmark_model_plus_dummy_delegate
+
+# Setting --use_dummy_delegate=true will apply the dummy delegate to the
+# TFLite model graph.
+bazel-bin/tensorflow/lite/delegates/utils/dummy_delegate/benchmark_model_plus_dummy_delegate --graph=/tmp/mobilenet-v2.tflite --use_dummy_delegate=true
+
+```
+
+### Option 2: Utilize Tensorflow Lite External Delegate
+In this **alternative approach to reuse existing Tensorflow Lite kernel testing
+and tooling**, we first create an external delegate adaptor like the [`external_delegate_adaptor.cc`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/delegates/utils/dummy_delegate/external_delegate_adaptor.cc) here, and create the corresponding BUILD target
+to build a dynamic library.
+
+Afterwards, one could build binaries or use pre-built ones to run with the
+dummy delegate as long as the binary is linked with the
+[`external_delegate_provider`](https://github.com/tensorflow/tensorflow/blob/8c6f2d55762f3fc94f98fdd8b3c5d59ee1276dba/tensorflow/lite/tools/delegates/BUILD#L145-L159)
+library which supports command-line flags as described
+[here](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/delegates#external-delegate-provider).
+Note this external delegate provider has already been linked to existing testing
+and tooling binaries.
+
+For example, the following illustrates how to benchmark the dummy delegate here
+via this external-delegate approach. We could use similar commands for testing
+and evaluation tools.
+
+```
+bazel build -c opt tensorflow/lite/delegates/utils/dummy_delegate:dummy_external_delegate.so
+
+# Copy the .so file to the directory that the external delegate will be loaded
+# from at your choice.
+cp bazel-bin/tensorflow/lite/delegates/utils/dummy_delegate/dummy_external_delegate.so /tmp
+
+bazel build -c opt tensorflow/lite/tools/benchmark:benchmark_model
+
+# Setting a non-empty --external_delegate_path value will trigger applying
+# the external delegate during runtime.
+bazel-bin/tensorflow/lite/tools/benchmark/benchmark_model \
+  --graph=/tmp/mobilenet-v2.tflite \
+  --external_delegate_path=/tmp/dummy_external_delegate.so \
+  --external_delegate_options='error_during_init:true;error_during_prepare:true'
+```
+
+It is worth noting the *external delegate* is the corresponding C++
+implementation of the *delegate* in Tensorflow Lite Python binding as shown
+[here](https://github.com/tensorflow/tensorflow/blob/7145fc0e49be01ef6943f4df386ce38567e37797/tensorflow/lite/python/interpreter.py#L42).
+Therefore, the dynamic external delegate adaptor library created here could be
+directly used with Tensorflow Lite Python APIs.
+
+More detailed guide on TFLite delegate is coming soon.

tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate.cc

@@ -0,0 +1,107 @@
+/* Copyright 2020 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/delegates/utils/dummy_delegate/dummy_delegate.h"
+
+#include <memory>
+#include <utility>
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/delegates/utils/simple_delegate.h"
+
+namespace tflite {
+namespace dummy_test {
+
+// Dummy delegate kernel.
+class DummyDelegateKernel : public SimpleDelegateKernelInterface {
+ public:
+  explicit DummyDelegateKernel(const DummyDelegateOptions& options)
+      : options_(options) {}
+
+  TfLiteStatus Init(TfLiteContext* context,
+                    const TfLiteDelegateParams* params) override {
+    return !options_.error_during_init ? kTfLiteOk : kTfLiteError;
+  }
+
+  TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) override {
+    return !options_.error_during_prepare ? kTfLiteOk : kTfLiteError;
+  }
+
+  TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) override {
+    return !options_.error_during_invoke ? kTfLiteOk : kTfLiteError;
+  }
+
+ private:
+  const DummyDelegateOptions options_;
+};
+
+// DummyDelegate implements the interface of SimpleDelegateInterface.
+// This holds the Delegate capabilities.
+class DummyDelegate : public SimpleDelegateInterface {
+ public:
+  explicit DummyDelegate(const DummyDelegateOptions& options)
+      : options_(options) {}
+  bool IsNodeSupportedByDelegate(const TfLiteRegistration* registration,
+                                 const TfLiteNode* node,
+                                 TfLiteContext* context) const override {
+    return options_.allowed_builtin_code == registration->builtin_code;
+  }
+
+  TfLiteStatus Initialize(TfLiteContext* context) override { return kTfLiteOk; }
+
+  const char* Name() const override {
+    static constexpr char kName[] = "DummyDelegate";
+    return kName;
+  }
+
+  std::unique_ptr<SimpleDelegateKernelInterface> CreateDelegateKernelInterface()
+      override {
+    return std::make_unique<DummyDelegateKernel>(options_);
+  }
+
+  SimpleDelegateInterface::Options DelegateOptions() const override {
+    // Use default options.
+    return SimpleDelegateInterface::Options();
+  }
+
+ private:
+  const DummyDelegateOptions options_;
+};
+
+}  // namespace dummy_test
+}  // namespace tflite
+
+DummyDelegateOptions TfLiteDummyDelegateOptionsDefault() {
+  DummyDelegateOptions options = {0};
+  // Just assign an invalid builtin code so that this dummy test delegate will
+  // not support any node by default.
+  options.allowed_builtin_code = -1;
+  return options;
+}
+
+// Creates a new delegate instance that need to be destroyed with
+// `TfLiteDummyDelegateDelete` when delegate is no longer used by TFLite.
+// When `options` is set to `nullptr`, the above default values are used:
+TfLiteDelegate* TfLiteDummyDelegateCreate(const DummyDelegateOptions* options) {
+  std::unique_ptr<tflite::dummy_test::DummyDelegate> dummy(
+      new tflite::dummy_test::DummyDelegate(
+          options ? *options : TfLiteDummyDelegateOptionsDefault()));
+  return tflite::TfLiteDelegateFactory::CreateSimpleDelegate(std::move(dummy));
+}
+
+// Destroys a delegate created with `TfLiteDummyDelegateCreate` call.
+void TfLiteDummyDelegateDelete(TfLiteDelegate* delegate) {
+  tflite::TfLiteDelegateFactory::DeleteSimpleDelegate(delegate);
+}

tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate.h

@@ -0,0 +1,61 @@
+/* Copyright 2020 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_DELEGATES_UTILS_DUMMY_DELEGATE_DUMMY_DELEGATE_H_
+#define TENSORFLOW_LITE_DELEGATES_UTILS_DUMMY_DELEGATE_DUMMY_DELEGATE_H_
+
+#include <memory>
+
+#include "tensorflow/lite/core/c/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+
+typedef struct {
+  // Allowed ops to delegate.
+  int allowed_builtin_code;
+  // Report error during init.
+  bool error_during_init;
+  // Report error during prepare.
+  bool error_during_prepare;
+  // Report error during invoke.
+  bool error_during_invoke;
+} DummyDelegateOptions;
+
+// Returns a structure with the default delegate options.
+DummyDelegateOptions TfLiteDummyDelegateOptionsDefault();
+
+// Creates a new delegate instance that needs to be destroyed with
+// `TfLiteDummyDelegateDelete` when delegate is no longer used by TFLite.
+// When `options` is set to `nullptr`, the above default values are used:
+TfLiteDelegate* TfLiteDummyDelegateCreate(const DummyDelegateOptions* options);
+
+// Destroys a delegate created with `TfLiteDummyDelegateCreate` call.
+void TfLiteDummyDelegateDelete(TfLiteDelegate* delegate);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+// A convenient wrapper that returns C++ std::unique_ptr for automatic memory
+// management.
+inline std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>
+TfLiteDummyDelegateCreateUnique(const DummyDelegateOptions* options) {
+  return std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>(
+      TfLiteDummyDelegateCreate(options), TfLiteDummyDelegateDelete);
+}
+
+#endif  // TENSORFLOW_LITE_DELEGATES_UTILS_DUMMY_DELEGATE_DUMMY_DELEGATE_H_

tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate_provider.cc

@@ -0,0 +1,76 @@
+/* Copyright 2020 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 <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate.h"
+#include "tensorflow/lite/tools/command_line_flags.h"
+#include "tensorflow/lite/tools/delegates/delegate_provider.h"
+#include "tensorflow/lite/tools/tool_params.h"
+
+namespace tflite {
+namespace tools {
+
+class DummyDelegateProvider : public DelegateProvider {
+ public:
+  DummyDelegateProvider() {
+    default_params_.AddParam("use_dummy_delegate",
+                             ToolParam::Create<bool>(false));
+  }
+
+  std::vector<Flag> CreateFlags(ToolParams* params) const final;
+
+  void LogParams(const ToolParams& params, bool verbose) const final;
+
+  TfLiteDelegatePtr CreateTfLiteDelegate(const ToolParams& params) const final;
+  std::pair<TfLiteDelegatePtr, int> CreateRankedTfLiteDelegate(
+      const ToolParams& params) const final;
+
+  std::string GetName() const final { return "DummyDelegate"; }
+};
+REGISTER_DELEGATE_PROVIDER(DummyDelegateProvider);
+
+std::vector<Flag> DummyDelegateProvider::CreateFlags(ToolParams* params) const {
+  std::vector<Flag> flags = {CreateFlag<bool>("use_dummy_delegate", params,
+                                              "use the dummy delegate.")};
+  return flags;
+}
+
+void DummyDelegateProvider::LogParams(const ToolParams& params,
+                                      bool verbose) const {
+  LOG_TOOL_PARAM(params, bool, "use_dummy_delegate", "Use dummy test delegate",
+                 verbose);
+}
+
+TfLiteDelegatePtr DummyDelegateProvider::CreateTfLiteDelegate(
+    const ToolParams& params) const {
+  if (params.Get<bool>("use_dummy_delegate")) {
+    auto default_options = TfLiteDummyDelegateOptionsDefault();
+    return TfLiteDummyDelegateCreateUnique(&default_options);
+  }
+  return TfLiteDelegatePtr(nullptr, [](TfLiteDelegate*) {});
+}
+
+std::pair<TfLiteDelegatePtr, int>
+DummyDelegateProvider::CreateRankedTfLiteDelegate(
+    const ToolParams& params) const {
+  auto ptr = CreateTfLiteDelegate(params);
+  return std::make_pair(std::move(ptr),
+                        params.GetPosition<bool>("use_dummy_delegate"));
+}
+}  // namespace tools
+}  // namespace tflite

tensorflow/lite/delegates/utils/dummy_delegate/external_delegate_adaptor.cc

@@ -0,0 +1,107 @@
+/* Copyright 2020 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 <cstddef>
+#include <string>
+#include <vector>
+
+#include "tensorflow/lite/core/c/common.h"
+#include "tensorflow/lite/delegates/external/external_delegate_interface.h"
+#include "tensorflow/lite/delegates/utils/dummy_delegate/dummy_delegate.h"
+#include "tensorflow/lite/tools/command_line_flags.h"
+#include "tensorflow/lite/tools/logging.h"
+
+namespace tflite {
+namespace tools {
+
+TfLiteDelegate* CreateDummyDelegateFromOptions(
+    const char* const* options_keys, const char* const* options_values,
+    size_t num_options) {
+  DummyDelegateOptions options = TfLiteDummyDelegateOptionsDefault();
+
+  // Parse key-values options to DummyDelegateOptions by mimicking them as
+  // command-line flags.
+  std::vector<const char*> argv;
+  argv.reserve(num_options + 1);
+  constexpr char kDummyDelegateParsing[] = "dummy_delegate_parsing";
+  argv.push_back(kDummyDelegateParsing);
+
+  std::vector<std::string> option_args;
+  option_args.reserve(num_options);
+  for (int i = 0; i < num_options; ++i) {
+    option_args.emplace_back("--");
+    option_args.rbegin()->append(options_keys[i]);
+    option_args.rbegin()->push_back('=');
+    option_args.rbegin()->append(options_values[i]);
+    argv.push_back(option_args.rbegin()->c_str());
+  }
+
+  constexpr char kAllowedBuiltinOp[] = "allowed_builtin_code";
+  constexpr char kReportErrorDuringInit[] = "error_during_init";
+  constexpr char kReportErrorDuringPrepare[] = "error_during_prepare";
+  constexpr char kReportErrorDuringInvoke[] = "error_during_invoke";
+
+  std::vector<tflite::Flag> flag_list = {
+      tflite::Flag::CreateFlag(kAllowedBuiltinOp, &options.allowed_builtin_code,
+                               "Allowed builtin code."),
+      tflite::Flag::CreateFlag(kReportErrorDuringInit,
+                               &options.error_during_init,
+                               "Report error during init."),
+      tflite::Flag::CreateFlag(kReportErrorDuringPrepare,
+                               &options.error_during_prepare,
+                               "Report error during prepare."),
+      tflite::Flag::CreateFlag(kReportErrorDuringInvoke,
+                               &options.error_during_invoke,
+                               "Report error during invoke."),
+  };
+
+  int argc = num_options + 1;
+  if (!tflite::Flags::Parse(&argc, argv.data(), flag_list)) {
+    return nullptr;
+  }
+
+  TFLITE_LOG(INFO) << "Dummy delegate: allowed_builtin_code set to "
+                   << options.allowed_builtin_code << ".";
+  TFLITE_LOG(INFO) << "Dummy delegate: error_during_init set to "
+                   << options.error_during_init << ".";
+  TFLITE_LOG(INFO) << "Dummy delegate: error_during_prepare set to "
+                   << options.error_during_prepare << ".";
+  TFLITE_LOG(INFO) << "Dummy delegate: error_during_invoke set to "
+                   << options.error_during_invoke << ".";
+
+  return TfLiteDummyDelegateCreate(&options);
+}
+
+}  // namespace tools
+}  // namespace tflite
+
+extern "C" {
+
+// Defines two symbols that need to be exported to use the TFLite external
+// delegate. See tensorflow/lite/delegates/external for details.
+extern TFL_EXTERNAL_DELEGATE_EXPORT TfLiteDelegate*
+tflite_plugin_create_delegate(const char* const* options_keys,
+                              const char* const* options_values,
+                              size_t num_options,
+                              void (*report_error)(const char*)) {
+  return tflite::tools::CreateDummyDelegateFromOptions(
+      options_keys, options_values, num_options);
+}
+
+TFL_EXTERNAL_DELEGATE_EXPORT void tflite_plugin_destroy_delegate(
+    TfLiteDelegate* delegate) {
+  TfLiteDummyDelegateDelete(delegate);
+}
+
+}  // extern "C"

tensorflow/lite/delegates/utils/dummy_delegate/external_delegate_test.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# 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.
+# ==============================================================================
+
+set -o errexit
+set -o nounset
+
+readonly benchmark_tool=tensorflow/lite/tools/benchmark/benchmark_model
+readonly external_delegate=tensorflow/lite/delegates/utils/dummy_delegate/dummy_external_delegate.so
+readonly model=external/tflite_mobilenet_float/mobilenet_v1_1.0_224.tflite
+readonly benchmark_log=/tmp/benchmark.out
+
+die() { echo "$@" >&2; exit 1; }
+
+$benchmark_tool --graph=$model \
+    --external_delegate_path=$external_delegate \
+    --external_delegate_options='error_during_init:true;error_during_prepare:true' \
+    >& $benchmark_log
+cat $benchmark_log
+grep -q 'EXTERNAL delegate created.' $benchmark_log \
+    || die "Didn't find expected log contents"
+
+echo "PASS"