From d6e53e76f2beff1e84c333549a7c62a6d63af03c Mon Sep 17 00:00:00 2001 From: Sachin Joglekar Date: Mon, 7 Dec 2020 13:18:54 -0800 Subject: [PATCH] Implement a telemetry library for delegates to report their settings/status for A@S PiperOrigin-RevId: 346165056 Change-Id: I31f3b14e9986d0d89d1d568f1c565bcfc6cf2783 --- tensorflow/lite/BUILD | 4 +- tensorflow/lite/core/api/profiler.h | 6 +- tensorflow/lite/delegates/BUILD | 23 +- tensorflow/lite/delegates/telemetry.cc | 49 + .../lite/delegates/{status.h => telemetry.h} | 47 +- tensorflow/lite/delegates/telemetry_test.cc | 141 ++ .../acceleration/configuration/BUILD | 3 + .../configuration/configuration_generated.h | 1444 +++++++++++++++++ tensorflow/lite/interpreter.cc | 2 +- tensorflow/lite/tools/make/Makefile | 6 +- tensorflow/opensource_only.files | 1 + 11 files changed, 1707 insertions(+), 19 deletions(-) create mode 100644 tensorflow/lite/delegates/telemetry.cc rename tensorflow/lite/delegates/{status.h => telemetry.h} (55%) create mode 100644 tensorflow/lite/delegates/telemetry_test.cc create mode 100644 tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h diff --git a/tensorflow/lite/BUILD b/tensorflow/lite/BUILD index bb736177035..a07ded54372 100644 --- a/tensorflow/lite/BUILD +++ b/tensorflow/lite/BUILD @@ -260,7 +260,7 @@ cc_library( "//tensorflow/lite/c:common", "//tensorflow/lite/core/api", "//tensorflow/lite/core/api:verifier", - "//tensorflow/lite/delegates:status", + "//tensorflow/lite/delegates:telemetry", "//tensorflow/lite/experimental/resource", "//tensorflow/lite/kernels/internal:compatibility", "//tensorflow/lite/profiling:platform_profiler", @@ -347,7 +347,7 @@ cc_library( "//tensorflow/lite/c:common", "//tensorflow/lite/core/api", "//tensorflow/lite/core/api:verifier", - "//tensorflow/lite/delegates:status", + "//tensorflow/lite/delegates:telemetry", "//tensorflow/lite/experimental/resource", "//tensorflow/lite/kernels/internal:compatibility", "//tensorflow/lite/profiling:platform_profiler", diff --git a/tensorflow/lite/core/api/profiler.h b/tensorflow/lite/core/api/profiler.h index 897efbe1438..f2dd12c2f95 100644 --- a/tensorflow/lite/core/api/profiler.h +++ b/tensorflow/lite/core/api/profiler.h @@ -181,12 +181,12 @@ class ScopedRuntimeInstrumentationProfile : public ScopedProfile { _profile_, __COUNTER__)((profiler), (tag), (node_index)) #define TFLITE_ADD_RUNTIME_INSTRUMENTATION_EVENT( \ - profiler, tag, delegate_status, interpreter_status) \ + profiler, tag, event_metadata1, event_metadata2) \ do { \ - if (!profiler) { \ + if (profiler) { \ const auto handle = profiler->BeginEvent( \ tag, Profiler::EventType::GENERAL_RUNTIME_INSTRUMENTATION_EVENT, \ - delegate_status, interpreter_status); \ + event_metadata1, event_metadata2); \ profiler->EndEvent(handle); \ } \ } while (false); diff --git a/tensorflow/lite/delegates/BUILD b/tensorflow/lite/delegates/BUILD index 4ac2493dbc2..4ad2bcd06e3 100644 --- a/tensorflow/lite/delegates/BUILD +++ b/tensorflow/lite/delegates/BUILD @@ -22,12 +22,31 @@ package( ) cc_library( - name = "status", - hdrs = ["status.h"], + name = "telemetry", + srcs = ["telemetry.cc"], + hdrs = ["telemetry.h"], compatible_with = get_compatible_with_portable(), copts = tflite_copts(), deps = [ "//tensorflow/lite/c:common", + "//tensorflow/lite/core/api", + "//tensorflow/lite/experimental/acceleration/configuration:configuration_fbs", + ], +) + +cc_test( + name = "telemetry_test", + srcs = ["telemetry_test.cc"], + linkopts = tflite_linkopts(), + linkstatic = 1, + deps = [ + ":telemetry", + "//tensorflow/lite/c:common", + "//tensorflow/lite/core/api", + "//tensorflow/lite/experimental/acceleration/configuration:configuration_fbs", + "//tensorflow/lite/profiling:profile_buffer", + "@com_google_googletest//:gtest_main", + "@flatbuffers", ], ) diff --git a/tensorflow/lite/delegates/telemetry.cc b/tensorflow/lite/delegates/telemetry.cc new file mode 100644 index 00000000000..cba84865f1a --- /dev/null +++ b/tensorflow/lite/delegates/telemetry.cc @@ -0,0 +1,49 @@ +/* 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/telemetry.h" + +#include "tensorflow/lite/c/common.h" +#include "tensorflow/lite/core/api/profiler.h" + +namespace tflite { +namespace delegates { + +// TODO(b/153131797): Add an IFTTT here once we have a profiler to interpret +// these events, so that the two components don't go out of sync. + +TfLiteStatus ReportDelegateSettings(TfLiteContext* context, + TfLiteDelegate* delegate, + const TFLiteSettings& settings) { + auto* profiler = reinterpret_cast(context->profiler); + const int64_t event_metadata1 = reinterpret_cast(delegate); + const int64_t event_metadata2 = reinterpret_cast(&settings); + TFLITE_ADD_RUNTIME_INSTRUMENTATION_EVENT(profiler, kDelegateSettingsTag, + event_metadata1, event_metadata2); + return kTfLiteOk; +} + +TfLiteStatus ReportDelegateStatus(TfLiteContext* context, + TfLiteDelegate* delegate, + const DelegateStatus& status) { + auto* profiler = reinterpret_cast(context->profiler); + TFLITE_ADD_RUNTIME_INSTRUMENTATION_EVENT(profiler, kDelegateStatusTag, + status.full_status(), + static_cast(kTfLiteOk)); + return kTfLiteOk; +} + +} // namespace delegates +} // namespace tflite diff --git a/tensorflow/lite/delegates/status.h b/tensorflow/lite/delegates/telemetry.h similarity index 55% rename from tensorflow/lite/delegates/status.h rename to tensorflow/lite/delegates/telemetry.h index e56bf7ce577..d7e92be5ac3 100644 --- a/tensorflow/lite/delegates/status.h +++ b/tensorflow/lite/delegates/telemetry.h @@ -19,19 +19,24 @@ limitations under the License. #include #include "tensorflow/lite/c/common.h" +#include "tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h" -// This file defines data structures to represent detailed TFLite delegate -// status, e.g. NNAPI delegate application failure because of a driver issue -// etc. Such status is ONLY to be used for internal APIs. -// Note, we simply use TfLiteStatus to represent high-level status while -// delegate-specific status codes are defined with DelegateStatus. +// This file implements utilities for delegate telemetry. These enable +// representation and reporting of hardware-specific configurations, status +// codes, etc. +// These APIs are for internal use *only*, and should be modified with care to +// avoid incompatibilities between delegates & runtime. // WARNING: This is an experimental feature that is subject to change. namespace tflite { namespace delegates { -// Defines the source of the code where it is generated from. We list all TFLite -// delegates that're officially implemented and available as of April, 2020 -// (i.e. w/ 'TFLITE_' prefix to imply this). +// Used to identify specific events for tflite::Profiler. +constexpr char kDelegateSettingsTag[] = "delegate_settings"; +constexpr char kDelegateStatusTag[] = "delegate_status"; + +// Defines the delegate or hardware-specific 'namespace' that a status code +// belongs to. For example, GPU delegate errors might be belong to TFLITE_GPU, +// while OpenCL-specific ones might be TFLITE_GPU_CL. enum class DelegateStatusSource { NONE = 0, TFLITE_GPU = 1, @@ -42,8 +47,16 @@ enum class DelegateStatusSource { MAX_NUM_SOURCES = std::numeric_limits::max(), }; -// Defines the detailed status that combines a DelegateStatusSource and a -// status int32_t code. +// DelegateStatus defines a namespaced status with a combination of +// DelegateStatusSource & the corresponding fine-grained 32-bit code. Used to +// convert to/from a 64-bit representation as follows: +// +// delegates::DelegateStatus status( +// delegates::DelegateStatusSource::TFLITE_NNAPI, +// ANEURALNETWORKS_OP_FAILED); +// int64_t code = status.full_status(); +// +// auto parsed_status = delegates::DelegateStatus(code); class DelegateStatus { public: DelegateStatus() : DelegateStatus(DelegateStatusSource::NONE, 0) {} @@ -77,6 +90,20 @@ class DelegateStatus { int32_t code_; }; +// Used by delegates to report their configuration/settings to TFLite. +// Calling this method adds a new GENERAL_RUNTIME_INSTRUMENTATION_EVENT to +// the runtime Profiler. +TfLiteStatus ReportDelegateSettings(TfLiteContext* context, + TfLiteDelegate* delegate, + const TFLiteSettings& settings); + +// Used by delegates to report their status to the TFLite runtime. +// Calling this method adds a new GENERAL_RUNTIME_INSTRUMENTATION_EVENT to +// the runtime Profiler. +TfLiteStatus ReportDelegateStatus(TfLiteContext* context, + TfLiteDelegate* delegate, + const DelegateStatus& status); + } // namespace delegates } // namespace tflite diff --git a/tensorflow/lite/delegates/telemetry_test.cc b/tensorflow/lite/delegates/telemetry_test.cc new file mode 100644 index 00000000000..759097c4d49 --- /dev/null +++ b/tensorflow/lite/delegates/telemetry_test.cc @@ -0,0 +1,141 @@ +/* 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/telemetry.h" + +#include + +#include +#include +#include "flatbuffers/flatbuffers.h" // from @flatbuffers +#include "tensorflow/lite/c/common.h" +#include "tensorflow/lite/core/api/profiler.h" +#include "tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h" +#include "tensorflow/lite/profiling/profile_buffer.h" + +namespace tflite { +namespace delegates { +namespace { + +constexpr int32_t kDummyCode = 2; +constexpr bool kDummyGpuPrecisionLossAllowed = true; +constexpr tflite::Delegate kDummyDelegate = tflite::Delegate_GPU; +constexpr DelegateStatusSource kDummySource = + DelegateStatusSource::TFLITE_NNAPI; + +TEST(TelemetryTest, StatusConversion) { + DelegateStatus status(kDummySource, kDummyCode); + int64_t serialized_int = status.full_status(); + DelegateStatus deserialized_status(serialized_int); + + EXPECT_EQ(kDummyCode, deserialized_status.code()); + EXPECT_EQ(kDummySource, deserialized_status.source()); + EXPECT_EQ(serialized_int, deserialized_status.full_status()); +} + +// Dummy profiler to test delegate reporting. +class DelegateProfiler : public Profiler { + public: + DelegateProfiler() {} + ~DelegateProfiler() override = default; + + uint32_t BeginEvent(const char* tag, EventType event_type, + int64_t event_metadata1, + int64_t event_metadata2) override { + int event_handle = -1; + if (event_type == + Profiler::EventType::GENERAL_RUNTIME_INSTRUMENTATION_EVENT && + std::string(tag) == kDelegateSettingsTag) { + event_buffer_.emplace_back(); + event_handle = event_buffer_.size(); + + // event_metadata1 is a pointer to a TfLiteDelegate. + EXPECT_NE(event_metadata1, 0); + auto* delegate = reinterpret_cast(event_metadata1); + EXPECT_EQ(delegate->flags, kTfLiteDelegateFlagsNone); + // event_metadata2 is a pointer to TFLiteSettings. + EXPECT_NE(event_metadata2, 0); + auto* settings = reinterpret_cast(event_metadata2); + EXPECT_EQ(settings->delegate(), kDummyDelegate); + EXPECT_EQ(settings->gpu_settings()->is_precision_loss_allowed(), + kDummyGpuPrecisionLossAllowed); + } else if (event_type == + Profiler::EventType::GENERAL_RUNTIME_INSTRUMENTATION_EVENT && + std::string(tag) == kDelegateStatusTag) { + event_buffer_.emplace_back(); + event_handle = event_buffer_.size(); + + EXPECT_EQ(event_metadata2, static_cast(kTfLiteOk)); + DelegateStatus reported_status(event_metadata1); + EXPECT_EQ(reported_status.source(), kDummySource); + EXPECT_EQ(reported_status.code(), kDummyCode); + } + + EXPECT_NE(-1, event_handle); + return event_handle; + } + + void EndEvent(uint32_t event_handle) override { + EXPECT_EQ(event_handle, event_buffer_.size()); + } + + int NumRecordedEvents() { return event_buffer_.size(); } + + private: + std::vector event_buffer_; +}; + +TEST(TelemetryTest, DelegateStatusReport) { + DelegateProfiler profiler; + TfLiteDelegate delegate = TfLiteDelegateCreate(); + TfLiteContext context; + context.profiler = &profiler; + DelegateStatus status(kDummySource, kDummyCode); + + EXPECT_EQ(ReportDelegateStatus(&context, &delegate, status), kTfLiteOk); + EXPECT_EQ(ReportDelegateStatus(&context, &delegate, status), kTfLiteOk); + EXPECT_EQ(profiler.NumRecordedEvents(), 2); +} + +TEST(TelemetryTest, DelegateSettingsReport) { + DelegateProfiler profiler; + TfLiteDelegate delegate = TfLiteDelegateCreate(); + TfLiteContext context; + context.profiler = &profiler; + + flatbuffers::FlatBufferBuilder flatbuffer_builder; + flatbuffers::Offset gpu_settings = + tflite::CreateGPUSettings( + flatbuffer_builder, + /**is_precision_loss_allowed**/ kDummyGpuPrecisionLossAllowed); + auto* tflite_settings_ptr = flatbuffers::GetTemporaryPointer( + flatbuffer_builder, + CreateTFLiteSettings(flatbuffer_builder, kDummyDelegate, + /*nnapi_settings=*/0, + /*gpu_settings=*/gpu_settings)); + + EXPECT_EQ(ReportDelegateSettings(&context, &delegate, *tflite_settings_ptr), + kTfLiteOk); + EXPECT_EQ(profiler.NumRecordedEvents(), 1); + + // Also report status to simulate typical use-case. + DelegateStatus status(kDummySource, kDummyCode); + EXPECT_EQ(ReportDelegateStatus(&context, &delegate, status), kTfLiteOk); + EXPECT_EQ(ReportDelegateStatus(&context, &delegate, status), kTfLiteOk); + EXPECT_EQ(profiler.NumRecordedEvents(), 3); +} + +} // namespace +} // namespace delegates +} // namespace tflite diff --git a/tensorflow/lite/experimental/acceleration/configuration/BUILD b/tensorflow/lite/experimental/acceleration/configuration/BUILD index 023db7b1c74..633da0764c4 100644 --- a/tensorflow/lite/experimental/acceleration/configuration/BUILD +++ b/tensorflow/lite/experimental/acceleration/configuration/BUILD @@ -14,6 +14,7 @@ # ============================================================================== load("@flatbuffers//:build_defs.bzl", "flatbuffer_cc_library", "flatbuffer_java_library", "flatc_path") +load("//tensorflow:tensorflow.bzl", "get_compatible_with_portable") package( default_visibility = [ @@ -32,6 +33,7 @@ genrule( $(location {}) --proto -o $(@D) $(location :configuration.proto) perl -p -i -e 's/tflite.proto/tflite/' $(@D)/configuration.fbs """.format(flatc_path), + compatible_with = get_compatible_with_portable(), tools = [ flatc_path, ], @@ -68,6 +70,7 @@ java_lite_proto_library( flatbuffer_cc_library( name = "configuration_fbs", srcs = [":configuration.fbs"], + compatible_with = get_compatible_with_portable(), ) flatbuffer_java_library( diff --git a/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h b/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h new file mode 100644 index 00000000000..53d455cf821 --- /dev/null +++ b/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h @@ -0,0 +1,1444 @@ +/* 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. +==============================================================================*/ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_CONFIGURATION_TFLITE_H_ +#define FLATBUFFERS_GENERATED_CONFIGURATION_TFLITE_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace tflite { + +struct ComputeSettings; +struct ComputeSettingsT; + +struct NNAPISettings; +struct NNAPISettingsT; + +struct GPUSettings; +struct GPUSettingsT; + +struct HexagonSettings; +struct HexagonSettingsT; + +struct XNNPackSettings; +struct XNNPackSettingsT; + +struct EdgeTpuSettings; +struct EdgeTpuSettingsT; + +struct CPUSettings; +struct CPUSettingsT; + +struct TFLiteSettings; +struct TFLiteSettingsT; + +struct FallbackSettings; +struct FallbackSettingsT; + +enum ExecutionPreference { + ExecutionPreference_ANY = 0, + ExecutionPreference_LOW_LATENCY = 1, + ExecutionPreference_LOW_POWER = 2, + ExecutionPreference_FORCE_CPU = 3, + ExecutionPreference_MIN = ExecutionPreference_ANY, + ExecutionPreference_MAX = ExecutionPreference_FORCE_CPU +}; + +inline const ExecutionPreference (&EnumValuesExecutionPreference())[4] { + static const ExecutionPreference values[] = { + ExecutionPreference_ANY, + ExecutionPreference_LOW_LATENCY, + ExecutionPreference_LOW_POWER, + ExecutionPreference_FORCE_CPU + }; + return values; +} + +inline const char * const *EnumNamesExecutionPreference() { + static const char * const names[5] = { + "ANY", + "LOW_LATENCY", + "LOW_POWER", + "FORCE_CPU", + nullptr + }; + return names; +} + +inline const char *EnumNameExecutionPreference(ExecutionPreference e) { + if (flatbuffers::IsOutRange(e, ExecutionPreference_ANY, ExecutionPreference_FORCE_CPU)) return ""; + const size_t index = static_cast(e); + return EnumNamesExecutionPreference()[index]; +} + +enum Delegate { + Delegate_NONE = 0, + Delegate_NNAPI = 1, + Delegate_GPU = 2, + Delegate_HEXAGON = 3, + Delegate_XNNPACK = 4, + Delegate_EDGETPU = 5, + Delegate_MIN = Delegate_NONE, + Delegate_MAX = Delegate_EDGETPU +}; + +inline const Delegate (&EnumValuesDelegate())[6] { + static const Delegate values[] = { + Delegate_NONE, + Delegate_NNAPI, + Delegate_GPU, + Delegate_HEXAGON, + Delegate_XNNPACK, + Delegate_EDGETPU + }; + return values; +} + +inline const char * const *EnumNamesDelegate() { + static const char * const names[7] = { + "NONE", + "NNAPI", + "GPU", + "HEXAGON", + "XNNPACK", + "EDGETPU", + nullptr + }; + return names; +} + +inline const char *EnumNameDelegate(Delegate e) { + if (flatbuffers::IsOutRange(e, Delegate_NONE, Delegate_EDGETPU)) return ""; + const size_t index = static_cast(e); + return EnumNamesDelegate()[index]; +} + +enum NNAPIExecutionPreference { + NNAPIExecutionPreference_UNDEFINED = 0, + NNAPIExecutionPreference_NNAPI_LOW_POWER = 1, + NNAPIExecutionPreference_NNAPI_FAST_SINGLE_ANSWER = 2, + NNAPIExecutionPreference_NNAPI_SUSTAINED_SPEED = 3, + NNAPIExecutionPreference_MIN = NNAPIExecutionPreference_UNDEFINED, + NNAPIExecutionPreference_MAX = NNAPIExecutionPreference_NNAPI_SUSTAINED_SPEED +}; + +inline const NNAPIExecutionPreference (&EnumValuesNNAPIExecutionPreference())[4] { + static const NNAPIExecutionPreference values[] = { + NNAPIExecutionPreference_UNDEFINED, + NNAPIExecutionPreference_NNAPI_LOW_POWER, + NNAPIExecutionPreference_NNAPI_FAST_SINGLE_ANSWER, + NNAPIExecutionPreference_NNAPI_SUSTAINED_SPEED + }; + return values; +} + +inline const char * const *EnumNamesNNAPIExecutionPreference() { + static const char * const names[5] = { + "UNDEFINED", + "NNAPI_LOW_POWER", + "NNAPI_FAST_SINGLE_ANSWER", + "NNAPI_SUSTAINED_SPEED", + nullptr + }; + return names; +} + +inline const char *EnumNameNNAPIExecutionPreference(NNAPIExecutionPreference e) { + if (flatbuffers::IsOutRange(e, NNAPIExecutionPreference_UNDEFINED, NNAPIExecutionPreference_NNAPI_SUSTAINED_SPEED)) return ""; + const size_t index = static_cast(e); + return EnumNamesNNAPIExecutionPreference()[index]; +} + +enum NNAPIExecutionPriority { + NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED = 0, + NNAPIExecutionPriority_NNAPI_PRIORITY_LOW = 1, + NNAPIExecutionPriority_NNAPI_PRIORITY_MEDIUM = 2, + NNAPIExecutionPriority_NNAPI_PRIORITY_HIGH = 3, + NNAPIExecutionPriority_MIN = NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED, + NNAPIExecutionPriority_MAX = NNAPIExecutionPriority_NNAPI_PRIORITY_HIGH +}; + +inline const NNAPIExecutionPriority (&EnumValuesNNAPIExecutionPriority())[4] { + static const NNAPIExecutionPriority values[] = { + NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED, + NNAPIExecutionPriority_NNAPI_PRIORITY_LOW, + NNAPIExecutionPriority_NNAPI_PRIORITY_MEDIUM, + NNAPIExecutionPriority_NNAPI_PRIORITY_HIGH + }; + return values; +} + +inline const char * const *EnumNamesNNAPIExecutionPriority() { + static const char * const names[5] = { + "NNAPI_PRIORITY_UNDEFINED", + "NNAPI_PRIORITY_LOW", + "NNAPI_PRIORITY_MEDIUM", + "NNAPI_PRIORITY_HIGH", + nullptr + }; + return names; +} + +inline const char *EnumNameNNAPIExecutionPriority(NNAPIExecutionPriority e) { + if (flatbuffers::IsOutRange(e, NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED, NNAPIExecutionPriority_NNAPI_PRIORITY_HIGH)) return ""; + const size_t index = static_cast(e); + return EnumNamesNNAPIExecutionPriority()[index]; +} + +enum GPUBackend { + GPUBackend_UNSET = 0, + GPUBackend_OPENCL = 1, + GPUBackend_OPENGL = 2, + GPUBackend_MIN = GPUBackend_UNSET, + GPUBackend_MAX = GPUBackend_OPENGL +}; + +inline const GPUBackend (&EnumValuesGPUBackend())[3] { + static const GPUBackend values[] = { + GPUBackend_UNSET, + GPUBackend_OPENCL, + GPUBackend_OPENGL + }; + return values; +} + +inline const char * const *EnumNamesGPUBackend() { + static const char * const names[4] = { + "UNSET", + "OPENCL", + "OPENGL", + nullptr + }; + return names; +} + +inline const char *EnumNameGPUBackend(GPUBackend e) { + if (flatbuffers::IsOutRange(e, GPUBackend_UNSET, GPUBackend_OPENGL)) return ""; + const size_t index = static_cast(e); + return EnumNamesGPUBackend()[index]; +} + +namespace EdgeTpuSettings_ { + +enum PowerState { + PowerState_UNDEFINED = 0, + PowerState_TPU_CORE_OFF = 1, + PowerState_READY = 2, + PowerState_READY_WITH_RETENTION = 3, + PowerState_ACTIVE_MIN_POWER = 4, + PowerState_ACTIVE_LOW_POWER = 5, + PowerState_ACTIVE = 6, + PowerState_OVER_DRIVE = 7, + PowerState_MIN = PowerState_UNDEFINED, + PowerState_MAX = PowerState_OVER_DRIVE +}; + +inline const PowerState (&EnumValuesPowerState())[8] { + static const PowerState values[] = { + PowerState_UNDEFINED, + PowerState_TPU_CORE_OFF, + PowerState_READY, + PowerState_READY_WITH_RETENTION, + PowerState_ACTIVE_MIN_POWER, + PowerState_ACTIVE_LOW_POWER, + PowerState_ACTIVE, + PowerState_OVER_DRIVE + }; + return values; +} + +inline const char * const *EnumNamesPowerState() { + static const char * const names[9] = { + "UNDEFINED", + "TPU_CORE_OFF", + "READY", + "READY_WITH_RETENTION", + "ACTIVE_MIN_POWER", + "ACTIVE_LOW_POWER", + "ACTIVE", + "OVER_DRIVE", + nullptr + }; + return names; +} + +inline const char *EnumNamePowerState(PowerState e) { + if (flatbuffers::IsOutRange(e, PowerState_UNDEFINED, PowerState_OVER_DRIVE)) return ""; + const size_t index = static_cast(e); + return EnumNamesPowerState()[index]; +} + +} // namespace EdgeTpuSettings_ + +struct ComputeSettingsT : public flatbuffers::NativeTable { + typedef ComputeSettings TableType; + tflite::ExecutionPreference preference; + std::unique_ptr tflite_settings; + std::string model_namespace_for_statistics; + std::string model_identifier_for_statistics; + ComputeSettingsT() + : preference(tflite::ExecutionPreference_ANY) { + } +}; + +struct ComputeSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ComputeSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PREFERENCE = 4, + VT_TFLITE_SETTINGS = 6, + VT_MODEL_NAMESPACE_FOR_STATISTICS = 8, + VT_MODEL_IDENTIFIER_FOR_STATISTICS = 10 + }; + tflite::ExecutionPreference preference() const { + return static_cast(GetField(VT_PREFERENCE, 0)); + } + const tflite::TFLiteSettings *tflite_settings() const { + return GetPointer(VT_TFLITE_SETTINGS); + } + const flatbuffers::String *model_namespace_for_statistics() const { + return GetPointer(VT_MODEL_NAMESPACE_FOR_STATISTICS); + } + const flatbuffers::String *model_identifier_for_statistics() const { + return GetPointer(VT_MODEL_IDENTIFIER_FOR_STATISTICS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PREFERENCE) && + VerifyOffset(verifier, VT_TFLITE_SETTINGS) && + verifier.VerifyTable(tflite_settings()) && + VerifyOffset(verifier, VT_MODEL_NAMESPACE_FOR_STATISTICS) && + verifier.VerifyString(model_namespace_for_statistics()) && + VerifyOffset(verifier, VT_MODEL_IDENTIFIER_FOR_STATISTICS) && + verifier.VerifyString(model_identifier_for_statistics()) && + verifier.EndTable(); + } + ComputeSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ComputeSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ComputeSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_preference(tflite::ExecutionPreference preference) { + fbb_.AddElement(ComputeSettings::VT_PREFERENCE, static_cast(preference), 0); + } + void add_tflite_settings(flatbuffers::Offset tflite_settings) { + fbb_.AddOffset(ComputeSettings::VT_TFLITE_SETTINGS, tflite_settings); + } + void add_model_namespace_for_statistics(flatbuffers::Offset model_namespace_for_statistics) { + fbb_.AddOffset(ComputeSettings::VT_MODEL_NAMESPACE_FOR_STATISTICS, model_namespace_for_statistics); + } + void add_model_identifier_for_statistics(flatbuffers::Offset model_identifier_for_statistics) { + fbb_.AddOffset(ComputeSettings::VT_MODEL_IDENTIFIER_FOR_STATISTICS, model_identifier_for_statistics); + } + explicit ComputeSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ComputeSettingsBuilder &operator=(const ComputeSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateComputeSettings( + flatbuffers::FlatBufferBuilder &_fbb, + tflite::ExecutionPreference preference = tflite::ExecutionPreference_ANY, + flatbuffers::Offset tflite_settings = 0, + flatbuffers::Offset model_namespace_for_statistics = 0, + flatbuffers::Offset model_identifier_for_statistics = 0) { + ComputeSettingsBuilder builder_(_fbb); + builder_.add_model_identifier_for_statistics(model_identifier_for_statistics); + builder_.add_model_namespace_for_statistics(model_namespace_for_statistics); + builder_.add_tflite_settings(tflite_settings); + builder_.add_preference(preference); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateComputeSettingsDirect( + flatbuffers::FlatBufferBuilder &_fbb, + tflite::ExecutionPreference preference = tflite::ExecutionPreference_ANY, + flatbuffers::Offset tflite_settings = 0, + const char *model_namespace_for_statistics = nullptr, + const char *model_identifier_for_statistics = nullptr) { + auto model_namespace_for_statistics__ = model_namespace_for_statistics ? _fbb.CreateString(model_namespace_for_statistics) : 0; + auto model_identifier_for_statistics__ = model_identifier_for_statistics ? _fbb.CreateString(model_identifier_for_statistics) : 0; + return tflite::CreateComputeSettings( + _fbb, + preference, + tflite_settings, + model_namespace_for_statistics__, + model_identifier_for_statistics__); +} + +flatbuffers::Offset CreateComputeSettings(flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct NNAPISettingsT : public flatbuffers::NativeTable { + typedef NNAPISettings TableType; + std::string accelerator_name; + std::string cache_directory; + std::string model_token; + tflite::NNAPIExecutionPreference execution_preference; + int32_t no_of_nnapi_instances_to_cache; + std::unique_ptr fallback_settings; + bool allow_nnapi_cpu_on_android_10_plus; + tflite::NNAPIExecutionPriority execution_priority; + bool allow_dynamic_dimensions; + bool allow_fp16_precision_for_fp32; + NNAPISettingsT() + : execution_preference(tflite::NNAPIExecutionPreference_UNDEFINED), + no_of_nnapi_instances_to_cache(0), + allow_nnapi_cpu_on_android_10_plus(false), + execution_priority(tflite::NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED), + allow_dynamic_dimensions(false), + allow_fp16_precision_for_fp32(false) { + } +}; + +struct NNAPISettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NNAPISettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ACCELERATOR_NAME = 4, + VT_CACHE_DIRECTORY = 6, + VT_MODEL_TOKEN = 8, + VT_EXECUTION_PREFERENCE = 10, + VT_NO_OF_NNAPI_INSTANCES_TO_CACHE = 12, + VT_FALLBACK_SETTINGS = 14, + VT_ALLOW_NNAPI_CPU_ON_ANDROID_10_PLUS = 16, + VT_EXECUTION_PRIORITY = 18, + VT_ALLOW_DYNAMIC_DIMENSIONS = 20, + VT_ALLOW_FP16_PRECISION_FOR_FP32 = 22 + }; + const flatbuffers::String *accelerator_name() const { + return GetPointer(VT_ACCELERATOR_NAME); + } + const flatbuffers::String *cache_directory() const { + return GetPointer(VT_CACHE_DIRECTORY); + } + const flatbuffers::String *model_token() const { + return GetPointer(VT_MODEL_TOKEN); + } + tflite::NNAPIExecutionPreference execution_preference() const { + return static_cast(GetField(VT_EXECUTION_PREFERENCE, 0)); + } + int32_t no_of_nnapi_instances_to_cache() const { + return GetField(VT_NO_OF_NNAPI_INSTANCES_TO_CACHE, 0); + } + const tflite::FallbackSettings *fallback_settings() const { + return GetPointer(VT_FALLBACK_SETTINGS); + } + bool allow_nnapi_cpu_on_android_10_plus() const { + return GetField(VT_ALLOW_NNAPI_CPU_ON_ANDROID_10_PLUS, 0) != 0; + } + tflite::NNAPIExecutionPriority execution_priority() const { + return static_cast(GetField(VT_EXECUTION_PRIORITY, 0)); + } + bool allow_dynamic_dimensions() const { + return GetField(VT_ALLOW_DYNAMIC_DIMENSIONS, 0) != 0; + } + bool allow_fp16_precision_for_fp32() const { + return GetField(VT_ALLOW_FP16_PRECISION_FOR_FP32, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ACCELERATOR_NAME) && + verifier.VerifyString(accelerator_name()) && + VerifyOffset(verifier, VT_CACHE_DIRECTORY) && + verifier.VerifyString(cache_directory()) && + VerifyOffset(verifier, VT_MODEL_TOKEN) && + verifier.VerifyString(model_token()) && + VerifyField(verifier, VT_EXECUTION_PREFERENCE) && + VerifyField(verifier, VT_NO_OF_NNAPI_INSTANCES_TO_CACHE) && + VerifyOffset(verifier, VT_FALLBACK_SETTINGS) && + verifier.VerifyTable(fallback_settings()) && + VerifyField(verifier, VT_ALLOW_NNAPI_CPU_ON_ANDROID_10_PLUS) && + VerifyField(verifier, VT_EXECUTION_PRIORITY) && + VerifyField(verifier, VT_ALLOW_DYNAMIC_DIMENSIONS) && + VerifyField(verifier, VT_ALLOW_FP16_PRECISION_FOR_FP32) && + verifier.EndTable(); + } + NNAPISettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(NNAPISettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct NNAPISettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_accelerator_name(flatbuffers::Offset accelerator_name) { + fbb_.AddOffset(NNAPISettings::VT_ACCELERATOR_NAME, accelerator_name); + } + void add_cache_directory(flatbuffers::Offset cache_directory) { + fbb_.AddOffset(NNAPISettings::VT_CACHE_DIRECTORY, cache_directory); + } + void add_model_token(flatbuffers::Offset model_token) { + fbb_.AddOffset(NNAPISettings::VT_MODEL_TOKEN, model_token); + } + void add_execution_preference(tflite::NNAPIExecutionPreference execution_preference) { + fbb_.AddElement(NNAPISettings::VT_EXECUTION_PREFERENCE, static_cast(execution_preference), 0); + } + void add_no_of_nnapi_instances_to_cache(int32_t no_of_nnapi_instances_to_cache) { + fbb_.AddElement(NNAPISettings::VT_NO_OF_NNAPI_INSTANCES_TO_CACHE, no_of_nnapi_instances_to_cache, 0); + } + void add_fallback_settings(flatbuffers::Offset fallback_settings) { + fbb_.AddOffset(NNAPISettings::VT_FALLBACK_SETTINGS, fallback_settings); + } + void add_allow_nnapi_cpu_on_android_10_plus(bool allow_nnapi_cpu_on_android_10_plus) { + fbb_.AddElement(NNAPISettings::VT_ALLOW_NNAPI_CPU_ON_ANDROID_10_PLUS, static_cast(allow_nnapi_cpu_on_android_10_plus), 0); + } + void add_execution_priority(tflite::NNAPIExecutionPriority execution_priority) { + fbb_.AddElement(NNAPISettings::VT_EXECUTION_PRIORITY, static_cast(execution_priority), 0); + } + void add_allow_dynamic_dimensions(bool allow_dynamic_dimensions) { + fbb_.AddElement(NNAPISettings::VT_ALLOW_DYNAMIC_DIMENSIONS, static_cast(allow_dynamic_dimensions), 0); + } + void add_allow_fp16_precision_for_fp32(bool allow_fp16_precision_for_fp32) { + fbb_.AddElement(NNAPISettings::VT_ALLOW_FP16_PRECISION_FOR_FP32, static_cast(allow_fp16_precision_for_fp32), 0); + } + explicit NNAPISettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NNAPISettingsBuilder &operator=(const NNAPISettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNNAPISettings( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset accelerator_name = 0, + flatbuffers::Offset cache_directory = 0, + flatbuffers::Offset model_token = 0, + tflite::NNAPIExecutionPreference execution_preference = tflite::NNAPIExecutionPreference_UNDEFINED, + int32_t no_of_nnapi_instances_to_cache = 0, + flatbuffers::Offset fallback_settings = 0, + bool allow_nnapi_cpu_on_android_10_plus = false, + tflite::NNAPIExecutionPriority execution_priority = tflite::NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED, + bool allow_dynamic_dimensions = false, + bool allow_fp16_precision_for_fp32 = false) { + NNAPISettingsBuilder builder_(_fbb); + builder_.add_execution_priority(execution_priority); + builder_.add_fallback_settings(fallback_settings); + builder_.add_no_of_nnapi_instances_to_cache(no_of_nnapi_instances_to_cache); + builder_.add_execution_preference(execution_preference); + builder_.add_model_token(model_token); + builder_.add_cache_directory(cache_directory); + builder_.add_accelerator_name(accelerator_name); + builder_.add_allow_fp16_precision_for_fp32(allow_fp16_precision_for_fp32); + builder_.add_allow_dynamic_dimensions(allow_dynamic_dimensions); + builder_.add_allow_nnapi_cpu_on_android_10_plus(allow_nnapi_cpu_on_android_10_plus); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateNNAPISettingsDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *accelerator_name = nullptr, + const char *cache_directory = nullptr, + const char *model_token = nullptr, + tflite::NNAPIExecutionPreference execution_preference = tflite::NNAPIExecutionPreference_UNDEFINED, + int32_t no_of_nnapi_instances_to_cache = 0, + flatbuffers::Offset fallback_settings = 0, + bool allow_nnapi_cpu_on_android_10_plus = false, + tflite::NNAPIExecutionPriority execution_priority = tflite::NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED, + bool allow_dynamic_dimensions = false, + bool allow_fp16_precision_for_fp32 = false) { + auto accelerator_name__ = accelerator_name ? _fbb.CreateString(accelerator_name) : 0; + auto cache_directory__ = cache_directory ? _fbb.CreateString(cache_directory) : 0; + auto model_token__ = model_token ? _fbb.CreateString(model_token) : 0; + return tflite::CreateNNAPISettings( + _fbb, + accelerator_name__, + cache_directory__, + model_token__, + execution_preference, + no_of_nnapi_instances_to_cache, + fallback_settings, + allow_nnapi_cpu_on_android_10_plus, + execution_priority, + allow_dynamic_dimensions, + allow_fp16_precision_for_fp32); +} + +flatbuffers::Offset CreateNNAPISettings(flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct GPUSettingsT : public flatbuffers::NativeTable { + typedef GPUSettings TableType; + bool is_precision_loss_allowed; + bool enable_quantized_inference; + tflite::GPUBackend force_backend; + GPUSettingsT() + : is_precision_loss_allowed(false), + enable_quantized_inference(true), + force_backend(tflite::GPUBackend_UNSET) { + } +}; + +struct GPUSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GPUSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IS_PRECISION_LOSS_ALLOWED = 4, + VT_ENABLE_QUANTIZED_INFERENCE = 6, + VT_FORCE_BACKEND = 8 + }; + bool is_precision_loss_allowed() const { + return GetField(VT_IS_PRECISION_LOSS_ALLOWED, 0) != 0; + } + bool enable_quantized_inference() const { + return GetField(VT_ENABLE_QUANTIZED_INFERENCE, 1) != 0; + } + tflite::GPUBackend force_backend() const { + return static_cast(GetField(VT_FORCE_BACKEND, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IS_PRECISION_LOSS_ALLOWED) && + VerifyField(verifier, VT_ENABLE_QUANTIZED_INFERENCE) && + VerifyField(verifier, VT_FORCE_BACKEND) && + verifier.EndTable(); + } + GPUSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GPUSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct GPUSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_is_precision_loss_allowed(bool is_precision_loss_allowed) { + fbb_.AddElement(GPUSettings::VT_IS_PRECISION_LOSS_ALLOWED, static_cast(is_precision_loss_allowed), 0); + } + void add_enable_quantized_inference(bool enable_quantized_inference) { + fbb_.AddElement(GPUSettings::VT_ENABLE_QUANTIZED_INFERENCE, static_cast(enable_quantized_inference), 1); + } + void add_force_backend(tflite::GPUBackend force_backend) { + fbb_.AddElement(GPUSettings::VT_FORCE_BACKEND, static_cast(force_backend), 0); + } + explicit GPUSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + GPUSettingsBuilder &operator=(const GPUSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateGPUSettings( + flatbuffers::FlatBufferBuilder &_fbb, + bool is_precision_loss_allowed = false, + bool enable_quantized_inference = true, + tflite::GPUBackend force_backend = tflite::GPUBackend_UNSET) { + GPUSettingsBuilder builder_(_fbb); + builder_.add_force_backend(force_backend); + builder_.add_enable_quantized_inference(enable_quantized_inference); + builder_.add_is_precision_loss_allowed(is_precision_loss_allowed); + return builder_.Finish(); +} + +flatbuffers::Offset CreateGPUSettings(flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct HexagonSettingsT : public flatbuffers::NativeTable { + typedef HexagonSettings TableType; + int32_t debug_level; + int32_t powersave_level; + bool print_graph_profile; + bool print_graph_debug; + HexagonSettingsT() + : debug_level(0), + powersave_level(0), + print_graph_profile(false), + print_graph_debug(false) { + } +}; + +struct HexagonSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HexagonSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEBUG_LEVEL = 4, + VT_POWERSAVE_LEVEL = 6, + VT_PRINT_GRAPH_PROFILE = 8, + VT_PRINT_GRAPH_DEBUG = 10 + }; + int32_t debug_level() const { + return GetField(VT_DEBUG_LEVEL, 0); + } + int32_t powersave_level() const { + return GetField(VT_POWERSAVE_LEVEL, 0); + } + bool print_graph_profile() const { + return GetField(VT_PRINT_GRAPH_PROFILE, 0) != 0; + } + bool print_graph_debug() const { + return GetField(VT_PRINT_GRAPH_DEBUG, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DEBUG_LEVEL) && + VerifyField(verifier, VT_POWERSAVE_LEVEL) && + VerifyField(verifier, VT_PRINT_GRAPH_PROFILE) && + VerifyField(verifier, VT_PRINT_GRAPH_DEBUG) && + verifier.EndTable(); + } + HexagonSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HexagonSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct HexagonSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_debug_level(int32_t debug_level) { + fbb_.AddElement(HexagonSettings::VT_DEBUG_LEVEL, debug_level, 0); + } + void add_powersave_level(int32_t powersave_level) { + fbb_.AddElement(HexagonSettings::VT_POWERSAVE_LEVEL, powersave_level, 0); + } + void add_print_graph_profile(bool print_graph_profile) { + fbb_.AddElement(HexagonSettings::VT_PRINT_GRAPH_PROFILE, static_cast(print_graph_profile), 0); + } + void add_print_graph_debug(bool print_graph_debug) { + fbb_.AddElement(HexagonSettings::VT_PRINT_GRAPH_DEBUG, static_cast(print_graph_debug), 0); + } + explicit HexagonSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HexagonSettingsBuilder &operator=(const HexagonSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHexagonSettings( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t debug_level = 0, + int32_t powersave_level = 0, + bool print_graph_profile = false, + bool print_graph_debug = false) { + HexagonSettingsBuilder builder_(_fbb); + builder_.add_powersave_level(powersave_level); + builder_.add_debug_level(debug_level); + builder_.add_print_graph_debug(print_graph_debug); + builder_.add_print_graph_profile(print_graph_profile); + return builder_.Finish(); +} + +flatbuffers::Offset CreateHexagonSettings(flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct XNNPackSettingsT : public flatbuffers::NativeTable { + typedef XNNPackSettings TableType; + int32_t num_threads; + XNNPackSettingsT() + : num_threads(0) { + } +}; + +struct XNNPackSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef XNNPackSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NUM_THREADS = 4 + }; + int32_t num_threads() const { + return GetField(VT_NUM_THREADS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NUM_THREADS) && + verifier.EndTable(); + } + XNNPackSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(XNNPackSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct XNNPackSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_num_threads(int32_t num_threads) { + fbb_.AddElement(XNNPackSettings::VT_NUM_THREADS, num_threads, 0); + } + explicit XNNPackSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + XNNPackSettingsBuilder &operator=(const XNNPackSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateXNNPackSettings( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t num_threads = 0) { + XNNPackSettingsBuilder builder_(_fbb); + builder_.add_num_threads(num_threads); + return builder_.Finish(); +} + +flatbuffers::Offset CreateXNNPackSettings(flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct EdgeTpuSettingsT : public flatbuffers::NativeTable { + typedef EdgeTpuSettings TableType; + tflite::EdgeTpuSettings_::PowerState inference_power_state; + EdgeTpuSettingsT() + : inference_power_state(tflite::EdgeTpuSettings_::PowerState_UNDEFINED) { + } +}; + +struct EdgeTpuSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EdgeTpuSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INFERENCE_POWER_STATE = 4 + }; + tflite::EdgeTpuSettings_::PowerState inference_power_state() const { + return static_cast(GetField(VT_INFERENCE_POWER_STATE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_INFERENCE_POWER_STATE) && + verifier.EndTable(); + } + EdgeTpuSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(EdgeTpuSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct EdgeTpuSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_inference_power_state(tflite::EdgeTpuSettings_::PowerState inference_power_state) { + fbb_.AddElement(EdgeTpuSettings::VT_INFERENCE_POWER_STATE, static_cast(inference_power_state), 0); + } + explicit EdgeTpuSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + EdgeTpuSettingsBuilder &operator=(const EdgeTpuSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateEdgeTpuSettings( + flatbuffers::FlatBufferBuilder &_fbb, + tflite::EdgeTpuSettings_::PowerState inference_power_state = tflite::EdgeTpuSettings_::PowerState_UNDEFINED) { + EdgeTpuSettingsBuilder builder_(_fbb); + builder_.add_inference_power_state(inference_power_state); + return builder_.Finish(); +} + +flatbuffers::Offset CreateEdgeTpuSettings(flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct CPUSettingsT : public flatbuffers::NativeTable { + typedef CPUSettings TableType; + int32_t num_threads; + CPUSettingsT() + : num_threads(0) { + } +}; + +struct CPUSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CPUSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NUM_THREADS = 4 + }; + int32_t num_threads() const { + return GetField(VT_NUM_THREADS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NUM_THREADS) && + verifier.EndTable(); + } + CPUSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CPUSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct CPUSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_num_threads(int32_t num_threads) { + fbb_.AddElement(CPUSettings::VT_NUM_THREADS, num_threads, 0); + } + explicit CPUSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CPUSettingsBuilder &operator=(const CPUSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateCPUSettings( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t num_threads = 0) { + CPUSettingsBuilder builder_(_fbb); + builder_.add_num_threads(num_threads); + return builder_.Finish(); +} + +flatbuffers::Offset CreateCPUSettings(flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct TFLiteSettingsT : public flatbuffers::NativeTable { + typedef TFLiteSettings TableType; + tflite::Delegate delegate; + std::unique_ptr nnapi_settings; + std::unique_ptr gpu_settings; + std::unique_ptr hexagon_settings; + std::unique_ptr xnnpack_settings; + std::unique_ptr cpu_settings; + int32_t max_delegated_partitions; + std::unique_ptr edgetpu_settings; + std::unique_ptr fallback_settings; + TFLiteSettingsT() + : delegate(tflite::Delegate_NONE), + max_delegated_partitions(0) { + } +}; + +struct TFLiteSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TFLiteSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DELEGATE = 4, + VT_NNAPI_SETTINGS = 6, + VT_GPU_SETTINGS = 8, + VT_HEXAGON_SETTINGS = 10, + VT_XNNPACK_SETTINGS = 12, + VT_CPU_SETTINGS = 14, + VT_MAX_DELEGATED_PARTITIONS = 16, + VT_EDGETPU_SETTINGS = 18, + VT_FALLBACK_SETTINGS = 20 + }; + tflite::Delegate delegate() const { + return static_cast(GetField(VT_DELEGATE, 0)); + } + const tflite::NNAPISettings *nnapi_settings() const { + return GetPointer(VT_NNAPI_SETTINGS); + } + const tflite::GPUSettings *gpu_settings() const { + return GetPointer(VT_GPU_SETTINGS); + } + const tflite::HexagonSettings *hexagon_settings() const { + return GetPointer(VT_HEXAGON_SETTINGS); + } + const tflite::XNNPackSettings *xnnpack_settings() const { + return GetPointer(VT_XNNPACK_SETTINGS); + } + const tflite::CPUSettings *cpu_settings() const { + return GetPointer(VT_CPU_SETTINGS); + } + int32_t max_delegated_partitions() const { + return GetField(VT_MAX_DELEGATED_PARTITIONS, 0); + } + const tflite::EdgeTpuSettings *edgetpu_settings() const { + return GetPointer(VT_EDGETPU_SETTINGS); + } + const tflite::FallbackSettings *fallback_settings() const { + return GetPointer(VT_FALLBACK_SETTINGS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DELEGATE) && + VerifyOffset(verifier, VT_NNAPI_SETTINGS) && + verifier.VerifyTable(nnapi_settings()) && + VerifyOffset(verifier, VT_GPU_SETTINGS) && + verifier.VerifyTable(gpu_settings()) && + VerifyOffset(verifier, VT_HEXAGON_SETTINGS) && + verifier.VerifyTable(hexagon_settings()) && + VerifyOffset(verifier, VT_XNNPACK_SETTINGS) && + verifier.VerifyTable(xnnpack_settings()) && + VerifyOffset(verifier, VT_CPU_SETTINGS) && + verifier.VerifyTable(cpu_settings()) && + VerifyField(verifier, VT_MAX_DELEGATED_PARTITIONS) && + VerifyOffset(verifier, VT_EDGETPU_SETTINGS) && + verifier.VerifyTable(edgetpu_settings()) && + VerifyOffset(verifier, VT_FALLBACK_SETTINGS) && + verifier.VerifyTable(fallback_settings()) && + verifier.EndTable(); + } + TFLiteSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TFLiteSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TFLiteSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_delegate(tflite::Delegate delegate) { + fbb_.AddElement(TFLiteSettings::VT_DELEGATE, static_cast(delegate), 0); + } + void add_nnapi_settings(flatbuffers::Offset nnapi_settings) { + fbb_.AddOffset(TFLiteSettings::VT_NNAPI_SETTINGS, nnapi_settings); + } + void add_gpu_settings(flatbuffers::Offset gpu_settings) { + fbb_.AddOffset(TFLiteSettings::VT_GPU_SETTINGS, gpu_settings); + } + void add_hexagon_settings(flatbuffers::Offset hexagon_settings) { + fbb_.AddOffset(TFLiteSettings::VT_HEXAGON_SETTINGS, hexagon_settings); + } + void add_xnnpack_settings(flatbuffers::Offset xnnpack_settings) { + fbb_.AddOffset(TFLiteSettings::VT_XNNPACK_SETTINGS, xnnpack_settings); + } + void add_cpu_settings(flatbuffers::Offset cpu_settings) { + fbb_.AddOffset(TFLiteSettings::VT_CPU_SETTINGS, cpu_settings); + } + void add_max_delegated_partitions(int32_t max_delegated_partitions) { + fbb_.AddElement(TFLiteSettings::VT_MAX_DELEGATED_PARTITIONS, max_delegated_partitions, 0); + } + void add_edgetpu_settings(flatbuffers::Offset edgetpu_settings) { + fbb_.AddOffset(TFLiteSettings::VT_EDGETPU_SETTINGS, edgetpu_settings); + } + void add_fallback_settings(flatbuffers::Offset fallback_settings) { + fbb_.AddOffset(TFLiteSettings::VT_FALLBACK_SETTINGS, fallback_settings); + } + explicit TFLiteSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TFLiteSettingsBuilder &operator=(const TFLiteSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTFLiteSettings( + flatbuffers::FlatBufferBuilder &_fbb, + tflite::Delegate delegate = tflite::Delegate_NONE, + flatbuffers::Offset nnapi_settings = 0, + flatbuffers::Offset gpu_settings = 0, + flatbuffers::Offset hexagon_settings = 0, + flatbuffers::Offset xnnpack_settings = 0, + flatbuffers::Offset cpu_settings = 0, + int32_t max_delegated_partitions = 0, + flatbuffers::Offset edgetpu_settings = 0, + flatbuffers::Offset fallback_settings = 0) { + TFLiteSettingsBuilder builder_(_fbb); + builder_.add_fallback_settings(fallback_settings); + builder_.add_edgetpu_settings(edgetpu_settings); + builder_.add_max_delegated_partitions(max_delegated_partitions); + builder_.add_cpu_settings(cpu_settings); + builder_.add_xnnpack_settings(xnnpack_settings); + builder_.add_hexagon_settings(hexagon_settings); + builder_.add_gpu_settings(gpu_settings); + builder_.add_nnapi_settings(nnapi_settings); + builder_.add_delegate(delegate); + return builder_.Finish(); +} + +flatbuffers::Offset CreateTFLiteSettings(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct FallbackSettingsT : public flatbuffers::NativeTable { + typedef FallbackSettings TableType; + bool allow_automatic_fallback_on_compilation_error; + bool allow_automatic_fallback_on_execution_error; + FallbackSettingsT() + : allow_automatic_fallback_on_compilation_error(false), + allow_automatic_fallback_on_execution_error(false) { + } +}; + +struct FallbackSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FallbackSettingsT NativeTableType; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ALLOW_AUTOMATIC_FALLBACK_ON_COMPILATION_ERROR = 4, + VT_ALLOW_AUTOMATIC_FALLBACK_ON_EXECUTION_ERROR = 6 + }; + bool allow_automatic_fallback_on_compilation_error() const { + return GetField(VT_ALLOW_AUTOMATIC_FALLBACK_ON_COMPILATION_ERROR, 0) != 0; + } + bool allow_automatic_fallback_on_execution_error() const { + return GetField(VT_ALLOW_AUTOMATIC_FALLBACK_ON_EXECUTION_ERROR, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ALLOW_AUTOMATIC_FALLBACK_ON_COMPILATION_ERROR) && + VerifyField(verifier, VT_ALLOW_AUTOMATIC_FALLBACK_ON_EXECUTION_ERROR) && + verifier.EndTable(); + } + FallbackSettingsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FallbackSettingsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct FallbackSettingsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_allow_automatic_fallback_on_compilation_error(bool allow_automatic_fallback_on_compilation_error) { + fbb_.AddElement(FallbackSettings::VT_ALLOW_AUTOMATIC_FALLBACK_ON_COMPILATION_ERROR, static_cast(allow_automatic_fallback_on_compilation_error), 0); + } + void add_allow_automatic_fallback_on_execution_error(bool allow_automatic_fallback_on_execution_error) { + fbb_.AddElement(FallbackSettings::VT_ALLOW_AUTOMATIC_FALLBACK_ON_EXECUTION_ERROR, static_cast(allow_automatic_fallback_on_execution_error), 0); + } + explicit FallbackSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FallbackSettingsBuilder &operator=(const FallbackSettingsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFallbackSettings( + flatbuffers::FlatBufferBuilder &_fbb, + bool allow_automatic_fallback_on_compilation_error = false, + bool allow_automatic_fallback_on_execution_error = false) { + FallbackSettingsBuilder builder_(_fbb); + builder_.add_allow_automatic_fallback_on_execution_error(allow_automatic_fallback_on_execution_error); + builder_.add_allow_automatic_fallback_on_compilation_error(allow_automatic_fallback_on_compilation_error); + return builder_.Finish(); +} + +flatbuffers::Offset CreateFallbackSettings(flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +inline ComputeSettingsT *ComputeSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ComputeSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void ComputeSettings::UnPackTo(ComputeSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = preference(); _o->preference = _e; } + { auto _e = tflite_settings(); if (_e) _o->tflite_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = model_namespace_for_statistics(); if (_e) _o->model_namespace_for_statistics = _e->str(); } + { auto _e = model_identifier_for_statistics(); if (_e) _o->model_identifier_for_statistics = _e->str(); } +} + +inline flatbuffers::Offset ComputeSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateComputeSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateComputeSettings(flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ComputeSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _preference = _o->preference; + auto _tflite_settings = _o->tflite_settings ? CreateTFLiteSettings(_fbb, _o->tflite_settings.get(), _rehasher) : 0; + auto _model_namespace_for_statistics = _o->model_namespace_for_statistics.empty() ? 0 : _fbb.CreateString(_o->model_namespace_for_statistics); + auto _model_identifier_for_statistics = _o->model_identifier_for_statistics.empty() ? 0 : _fbb.CreateString(_o->model_identifier_for_statistics); + return tflite::CreateComputeSettings( + _fbb, + _preference, + _tflite_settings, + _model_namespace_for_statistics, + _model_identifier_for_statistics); +} + +inline NNAPISettingsT *NNAPISettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new NNAPISettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void NNAPISettings::UnPackTo(NNAPISettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = accelerator_name(); if (_e) _o->accelerator_name = _e->str(); } + { auto _e = cache_directory(); if (_e) _o->cache_directory = _e->str(); } + { auto _e = model_token(); if (_e) _o->model_token = _e->str(); } + { auto _e = execution_preference(); _o->execution_preference = _e; } + { auto _e = no_of_nnapi_instances_to_cache(); _o->no_of_nnapi_instances_to_cache = _e; } + { auto _e = fallback_settings(); if (_e) _o->fallback_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = allow_nnapi_cpu_on_android_10_plus(); _o->allow_nnapi_cpu_on_android_10_plus = _e; } + { auto _e = execution_priority(); _o->execution_priority = _e; } + { auto _e = allow_dynamic_dimensions(); _o->allow_dynamic_dimensions = _e; } + { auto _e = allow_fp16_precision_for_fp32(); _o->allow_fp16_precision_for_fp32 = _e; } +} + +inline flatbuffers::Offset NNAPISettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateNNAPISettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateNNAPISettings(flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NNAPISettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _accelerator_name = _o->accelerator_name.empty() ? 0 : _fbb.CreateString(_o->accelerator_name); + auto _cache_directory = _o->cache_directory.empty() ? 0 : _fbb.CreateString(_o->cache_directory); + auto _model_token = _o->model_token.empty() ? 0 : _fbb.CreateString(_o->model_token); + auto _execution_preference = _o->execution_preference; + auto _no_of_nnapi_instances_to_cache = _o->no_of_nnapi_instances_to_cache; + auto _fallback_settings = _o->fallback_settings ? CreateFallbackSettings(_fbb, _o->fallback_settings.get(), _rehasher) : 0; + auto _allow_nnapi_cpu_on_android_10_plus = _o->allow_nnapi_cpu_on_android_10_plus; + auto _execution_priority = _o->execution_priority; + auto _allow_dynamic_dimensions = _o->allow_dynamic_dimensions; + auto _allow_fp16_precision_for_fp32 = _o->allow_fp16_precision_for_fp32; + return tflite::CreateNNAPISettings( + _fbb, + _accelerator_name, + _cache_directory, + _model_token, + _execution_preference, + _no_of_nnapi_instances_to_cache, + _fallback_settings, + _allow_nnapi_cpu_on_android_10_plus, + _execution_priority, + _allow_dynamic_dimensions, + _allow_fp16_precision_for_fp32); +} + +inline GPUSettingsT *GPUSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new GPUSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void GPUSettings::UnPackTo(GPUSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = is_precision_loss_allowed(); _o->is_precision_loss_allowed = _e; } + { auto _e = enable_quantized_inference(); _o->enable_quantized_inference = _e; } + { auto _e = force_backend(); _o->force_backend = _e; } +} + +inline flatbuffers::Offset GPUSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateGPUSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateGPUSettings(flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GPUSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _is_precision_loss_allowed = _o->is_precision_loss_allowed; + auto _enable_quantized_inference = _o->enable_quantized_inference; + auto _force_backend = _o->force_backend; + return tflite::CreateGPUSettings( + _fbb, + _is_precision_loss_allowed, + _enable_quantized_inference, + _force_backend); +} + +inline HexagonSettingsT *HexagonSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new HexagonSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void HexagonSettings::UnPackTo(HexagonSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = debug_level(); _o->debug_level = _e; } + { auto _e = powersave_level(); _o->powersave_level = _e; } + { auto _e = print_graph_profile(); _o->print_graph_profile = _e; } + { auto _e = print_graph_debug(); _o->print_graph_debug = _e; } +} + +inline flatbuffers::Offset HexagonSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateHexagonSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateHexagonSettings(flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HexagonSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _debug_level = _o->debug_level; + auto _powersave_level = _o->powersave_level; + auto _print_graph_profile = _o->print_graph_profile; + auto _print_graph_debug = _o->print_graph_debug; + return tflite::CreateHexagonSettings( + _fbb, + _debug_level, + _powersave_level, + _print_graph_profile, + _print_graph_debug); +} + +inline XNNPackSettingsT *XNNPackSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new XNNPackSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void XNNPackSettings::UnPackTo(XNNPackSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = num_threads(); _o->num_threads = _e; } +} + +inline flatbuffers::Offset XNNPackSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateXNNPackSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateXNNPackSettings(flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const XNNPackSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _num_threads = _o->num_threads; + return tflite::CreateXNNPackSettings( + _fbb, + _num_threads); +} + +inline EdgeTpuSettingsT *EdgeTpuSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new EdgeTpuSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void EdgeTpuSettings::UnPackTo(EdgeTpuSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = inference_power_state(); _o->inference_power_state = _e; } +} + +inline flatbuffers::Offset EdgeTpuSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateEdgeTpuSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateEdgeTpuSettings(flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EdgeTpuSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _inference_power_state = _o->inference_power_state; + return tflite::CreateEdgeTpuSettings( + _fbb, + _inference_power_state); +} + +inline CPUSettingsT *CPUSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new CPUSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void CPUSettings::UnPackTo(CPUSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = num_threads(); _o->num_threads = _e; } +} + +inline flatbuffers::Offset CPUSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateCPUSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateCPUSettings(flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CPUSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _num_threads = _o->num_threads; + return tflite::CreateCPUSettings( + _fbb, + _num_threads); +} + +inline TFLiteSettingsT *TFLiteSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new TFLiteSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void TFLiteSettings::UnPackTo(TFLiteSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = delegate(); _o->delegate = _e; } + { auto _e = nnapi_settings(); if (_e) _o->nnapi_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = gpu_settings(); if (_e) _o->gpu_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = hexagon_settings(); if (_e) _o->hexagon_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = xnnpack_settings(); if (_e) _o->xnnpack_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = cpu_settings(); if (_e) _o->cpu_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = max_delegated_partitions(); _o->max_delegated_partitions = _e; } + { auto _e = edgetpu_settings(); if (_e) _o->edgetpu_settings = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = fallback_settings(); if (_e) _o->fallback_settings = std::unique_ptr(_e->UnPack(_resolver)); } +} + +inline flatbuffers::Offset TFLiteSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTFLiteSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTFLiteSettings(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TFLiteSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _delegate = _o->delegate; + auto _nnapi_settings = _o->nnapi_settings ? CreateNNAPISettings(_fbb, _o->nnapi_settings.get(), _rehasher) : 0; + auto _gpu_settings = _o->gpu_settings ? CreateGPUSettings(_fbb, _o->gpu_settings.get(), _rehasher) : 0; + auto _hexagon_settings = _o->hexagon_settings ? CreateHexagonSettings(_fbb, _o->hexagon_settings.get(), _rehasher) : 0; + auto _xnnpack_settings = _o->xnnpack_settings ? CreateXNNPackSettings(_fbb, _o->xnnpack_settings.get(), _rehasher) : 0; + auto _cpu_settings = _o->cpu_settings ? CreateCPUSettings(_fbb, _o->cpu_settings.get(), _rehasher) : 0; + auto _max_delegated_partitions = _o->max_delegated_partitions; + auto _edgetpu_settings = _o->edgetpu_settings ? CreateEdgeTpuSettings(_fbb, _o->edgetpu_settings.get(), _rehasher) : 0; + auto _fallback_settings = _o->fallback_settings ? CreateFallbackSettings(_fbb, _o->fallback_settings.get(), _rehasher) : 0; + return tflite::CreateTFLiteSettings( + _fbb, + _delegate, + _nnapi_settings, + _gpu_settings, + _hexagon_settings, + _xnnpack_settings, + _cpu_settings, + _max_delegated_partitions, + _edgetpu_settings, + _fallback_settings); +} + +inline FallbackSettingsT *FallbackSettings::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new FallbackSettingsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void FallbackSettings::UnPackTo(FallbackSettingsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = allow_automatic_fallback_on_compilation_error(); _o->allow_automatic_fallback_on_compilation_error = _e; } + { auto _e = allow_automatic_fallback_on_execution_error(); _o->allow_automatic_fallback_on_execution_error = _e; } +} + +inline flatbuffers::Offset FallbackSettings::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateFallbackSettings(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateFallbackSettings(flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FallbackSettingsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _allow_automatic_fallback_on_compilation_error = _o->allow_automatic_fallback_on_compilation_error; + auto _allow_automatic_fallback_on_execution_error = _o->allow_automatic_fallback_on_execution_error; + return tflite::CreateFallbackSettings( + _fbb, + _allow_automatic_fallback_on_compilation_error, + _allow_automatic_fallback_on_execution_error); +} + +} // namespace tflite + +#endif // FLATBUFFERS_GENERATED_CONFIGURATION_TFLITE_H_ diff --git a/tensorflow/lite/interpreter.cc b/tensorflow/lite/interpreter.cc index b5ef31edc4d..6b2d24e9d1c 100644 --- a/tensorflow/lite/interpreter.cc +++ b/tensorflow/lite/interpreter.cc @@ -24,7 +24,7 @@ limitations under the License. #include "tensorflow/lite/c/common.h" #include "tensorflow/lite/context_util.h" #include "tensorflow/lite/core/api/error_reporter.h" -#include "tensorflow/lite/delegates/status.h" +#include "tensorflow/lite/delegates/telemetry.h" #include "tensorflow/lite/graph_info.h" #include "tensorflow/lite/memory_planner.h" #include "tensorflow/lite/minimal_logging.h" diff --git a/tensorflow/lite/tools/make/Makefile b/tensorflow/lite/tools/make/Makefile index 4debaaeeefb..3aac9030f0a 100644 --- a/tensorflow/lite/tools/make/Makefile +++ b/tensorflow/lite/tools/make/Makefile @@ -345,14 +345,18 @@ all: $(LIB_PATH) $(MINIMAL_BINARY) $(BENCHMARK_BINARY) $(BENCHMARK_PERF_OPTIONS # The target that's compiled for micro-controllers micro: $(LIB_PATH) -# Hack for generating schema file bypassing flatbuffer parsing +# Hack for generating schema files bypassing flatbuffer parsing tensorflow/lite/schema/schema_generated.h: @cp -u tensorflow/lite/schema/schema_generated.h.oss tensorflow/lite/schema/schema_generated.h + @cp -u tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h.oss tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h # Gathers together all the objects we've compiled into a single '.a' archive. $(LIB_PATH): tensorflow/lite/schema/schema_generated.h $(LIB_OBJS) @mkdir -p $(dir $@) $(AR) $(ARFLAGS) $(LIB_PATH) $(LIB_OBJS) +$(LIB_PATH): tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h $(LIB_OBJS) + @mkdir -p $(dir $@) + $(AR) $(ARFLAGS) $(LIB_PATH) $(LIB_OBJS) lib: $(LIB_PATH) diff --git a/tensorflow/opensource_only.files b/tensorflow/opensource_only.files index bf8bd7ab6bb..69ffe484758 100644 --- a/tensorflow/opensource_only.files +++ b/tensorflow/opensource_only.files @@ -18,6 +18,7 @@ tensorflow/lite/core/shims/cc/model_builder.h tensorflow/lite/delegates/gpu/cl/compiled_program_cache_generated.h tensorflow/lite/delegates/gpu/cl/serialization_generated.h tensorflow/lite/delegates/gpu/common/task/serialization_base_generated.h +tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h tensorflow/lite/micro/build_def.bzl tensorflow/lite/schema/schema_generated.h tensorflow/python/autograph/core/config.py