xmos-ai-tools 1.1.2.dev216__py3-none-macosx_11_0_arm64.whl → 1.1.2.dev236__py3-none-macosx_11_0_arm64.whl

xmos_ai_tools/runtime/include/tensorflow/lite/micro/python/interpreter/src/python_ops_resolver.h

@@ -0,0 +1,21 @@
+/* Copyright 2023 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_MICRO_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_
+#define TENSORFLOW_LITE_MICRO_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_
+
+// TODO(b/286456378): remove once this shim is no longer needed.
+#include "python/tflite_micro/python_ops_resolver.h"
+
+#endif  // TENSORFLOW_LITE_MICRO_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/test_helper_custom_ops.h

@@ -20,10 +20,9 @@ limitations under the License.
 #include <limits>
 
 #include "flatbuffers/flatbuffers.h"  // from @flatbuffers
-#include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
-#include "tensorflow/lite/micro/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_common.h"
 #include "tensorflow/lite/micro/micro_utils.h"
 #include "tensorflow/lite/portable_type_to_tflitetype.h"
 #include "tensorflow/lite/schema/schema_generated.h"
@@ -33,8 +32,8 @@ namespace testing {
 
 class PackerOp {
  public:
-  static const TfLiteRegistration_V1* getRegistration();
-  static TfLiteRegistration_V1* GetMutableRegistration();
+  static const TFLMRegistration* getRegistration();
+  static TFLMRegistration* GetMutableRegistration();
   static void* Init(TfLiteContext* context, const char* buffer, size_t length);
   static void Free(TfLiteContext* context, void* buffer);
   static TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node);

xmos_ai_tools/runtime/include/tensorflow/lite/micro/test_helpers.h

@@ -16,14 +16,16 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_MICRO_TEST_HELPERS_H_
 #define TENSORFLOW_LITE_MICRO_TEST_HELPERS_H_
 
+#include <algorithm>
 #include <cstdint>
 #include <limits>
+#include <type_traits>
 
 #include "flatbuffers/flatbuffers.h"  // from @flatbuffers
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
-#include "tensorflow/lite/micro/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
 #include "tensorflow/lite/micro/micro_utils.h"
 #include "tensorflow/lite/portable_type_to_tflitetype.h"
 #include "tensorflow/lite/schema/schema_generated.h"
@@ -32,6 +34,7 @@ namespace tflite {
 namespace testing {
 
 constexpr int kOfflinePlannerHeaderSize = 3;
+using TestingOpResolver = tflite::MicroMutableOpResolver<10>;
 
 struct NodeConnection_ {
   std::initializer_list<int32_t> input;
@@ -55,8 +58,8 @@ class SimpleStatefulOp {
   };
 
  public:
-  static const TfLiteRegistration_V1* getRegistration();
-  static TfLiteRegistration_V1* GetMutableRegistration();
+  static const TFLMRegistration* getRegistration();
+  static TFLMRegistration* GetMutableRegistration();
   static void* Init(TfLiteContext* context, const char* buffer, size_t length);
   static TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node);
   static TfLiteStatus Invoke(TfLiteContext* context, TfLiteNode* node);
@@ -64,8 +67,8 @@ class SimpleStatefulOp {
 
 class MockCustom {
  public:
-  static const TfLiteRegistration_V1* getRegistration();
-  static TfLiteRegistration_V1* GetMutableRegistration();
+  static const TFLMRegistration* getRegistration();
+  static TFLMRegistration* GetMutableRegistration();
   static void* Init(TfLiteContext* context, const char* buffer, size_t length);
   static void Free(TfLiteContext* context, void* buffer);
   static TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node);
@@ -78,8 +81,8 @@ class MockCustom {
 // the sum of the inputs.
 class MultipleInputs {
  public:
-  static const TfLiteRegistration_V1* getRegistration();
-  static TfLiteRegistration_V1* GetMutableRegistration();
+  static const TFLMRegistration* getRegistration();
+  static TFLMRegistration* GetMutableRegistration();
   static void* Init(TfLiteContext* context, const char* buffer, size_t length);
   static void Free(TfLiteContext* context, void* buffer);
   static TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node);
@@ -91,8 +94,8 @@ class MultipleInputs {
 // A simple no-op operator.
 class NoOp {
  public:
-  static const TfLiteRegistration_V1* getRegistration();
-  static TfLiteRegistration_V1* GetMutableRegistration();
+  static const TFLMRegistration* getRegistration();
+  static TFLMRegistration* GetMutableRegistration();
   static void* Init(TfLiteContext* context, const char* buffer, size_t length);
   static void Free(TfLiteContext* context, void* buffer);
   static TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node);
@@ -102,7 +105,7 @@ class NoOp {
 };
 
 // Returns an Op Resolver that can be used in the testing code.
-AllOpsResolver GetOpResolver();
+TfLiteStatus GetTestingOpResolver(TestingOpResolver& op_resolver);
 
 // Returns a simple example flatbuffer TensorFlow Lite model. Contains 1 input,
 // 1 layer of weights, 1 output Tensor, and 1 operator.
@@ -192,7 +195,7 @@ void PopulateContext(TfLiteTensor* tensors, int tensors_size,
 
 // Create a TfLiteIntArray from an array of ints.  The first element in the
 // supplied array must be the size of the array expressed as an int.
-TfLiteIntArray* IntArrayFromInts(int* int_array);
+TfLiteIntArray* IntArrayFromInts(const int* int_array);
 
 // Create a TfLiteFloatArray from an array of floats.  The first element in the
 // supplied array must be the size of the array expressed as a float.
@@ -297,7 +300,7 @@ TfLiteTensor CreateSymmetricPerChannelQuantizedTensor(
 // Returns the number of tensors in the default subgraph for a tflite::Model.
 size_t GetModelTensorCount(const Model* model);
 
-// Derives the quantization scaling factor from a min and max range.
+// Derives the asymmetric quantization scaling factor from a min and max range.
 template <typename T>
 inline float ScaleFromMinMax(const float min, const float max) {
   return (max - min) /
@@ -305,6 +308,19 @@ inline float ScaleFromMinMax(const float min, const float max) {
                             std::numeric_limits<T>::min());
 }
 
+// Derives the symmetric quantization scaling factor from a min and max range.
+template <typename T>
+inline float SymmetricScaleFromMinMax(const float min, const float max) {
+  const int32_t kScale =
+      std::numeric_limits<typename std::make_signed<T>::type>::max();
+  const float range = std::max(std::abs(min), std::abs(max));
+  if (range == 0) {
+    return 1.0f;
+  } else {
+    return range / kScale;
+  }
+}
+
 // Derives the quantization zero point from a min and max range.
 template <typename T>
 inline int ZeroPointFromMinMax(const float min, const float max) {

xmos_ai_tools/runtime/include/tensorflow/lite/micro/testing/micro_test.h

@@ -259,6 +259,7 @@ inline void InitializeTest() { InitializeTarget(); }
         MicroPrintf("FAIL: %s did not match %s", string1, string2, __FILE__, \
                     __LINE__);                                               \
         micro_test::did_test_fail = true;                                    \
+        break;                                                               \
       }                                                                      \
     }                                                                        \
   } while (false)

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tools/benchmarking/log_utils.h

@@ -0,0 +1,273 @@
+/* Copyright 2023 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 TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_
+#define TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_
+
+#include <algorithm>
+#include <cstdarg>
+#include <cstdint>
+#include <cstring>
+
+#include "tensorflow/lite/micro/micro_log.h"
+
+namespace tflite {
+
+// The maxmimum length of a string.
+static constexpr int kMaxStringLength = 32;
+
+// The maximum length of a table row, applies to the header as well.
+static constexpr int kMaxRowLength = 100;
+
+// The default padding between columns in a table.
+static constexpr int kDefaultColumnPadding = 4;
+
+// Defines how formatted data is printed to stdout.
+enum class PrettyPrintType {
+  // Prints as a CSV file.
+  kCsv,
+  // Prints as a formatted table.
+  kTable,
+};
+
+// Returns the length of the longest string in an array.
+// Args:
+// - strings: An array of strings.
+// - count: The number of strings in the array.
+int GetLongestStringLength(const char strings[][kMaxStringLength], int count);
+
+// Adds padding between two columns in a table.
+// ex) "hello" is being inserted into a column. The largest value in that column
+//     is 10, and there's a global padding of 4 spaces. Therefore, 9 spaces (10
+//     - 5 + 4) are added as padding.
+// Args:
+// - string: The input padding string.
+// - size: The size of the string that's being inserted into a column.
+// - max_size: The size of the largest string in the column.
+// - padding: The amount of padding to add to each column regardless of its
+//     size.
+void FillColumnPadding(char* string, int size, int max_size,
+                       int padding = kDefaultColumnPadding);
+
+// Fills a string with a specified value.
+// Args:
+// - string: The input string. This is filled in with the specified value.
+// - size: The size of the string after being filled in. This must be less than
+//     the allocated space for the string.
+// - buffer_size: The size of the string's buffer.
+// - value: The value to insert into the string. Defaults to a space.
+void FillString(char* string, int size, int buffer_size, char value = ' ');
+
+// Concatenates the input string onto the first.
+// Args:
+// - output: The destination string for where to append input.
+// - input: The input string to concatenate.
+// - size: The number of characters to concatenate from the first string. If
+//     negative, the whole input string will be concatenated.
+void MicroStrcat(char* output, const char* input, int size = -1);
+
+// Copies the input string into the output.
+void MicroStrcpy(char* output, const char* input);
+
+// Formats a division operation to have a specified number of decimal places.
+// Args:
+// - output: The output string to be formatted.
+// - numerator: The numerator in the division operation.
+// - denominator: The denominator in the division operation.
+// - decimal places: The number of decimal places to print to.
+void FormatIntegerDivide(char* output, int64_t numerator, int64_t denominator,
+                         int decimal_places);
+
+// Formats a division operation as a percentage.
+// Args:
+// - output: The output string to be formatted.
+// - numerator: The numerator in the division operation.
+// - denominator: The denominator in the division operation.
+// - decimal places: The number of decimal places to print to.
+void FormatAsPercentage(char* output, int64_t numerator, int64_t denominator,
+                        int decimal_places);
+
+void PrettyPrintTableHeader(PrettyPrintType type, const char* table_name);
+
+// Formats a number as a string.
+// Args:
+// - output: The location of where to write the formatted number.
+// - value: The value to write to a string.
+template <typename T>
+void FormatNumber(char* output, T value);
+
+// Pretty prints a table to stdout.
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex) PrintTable<3, 25>(headers, data, 4);
+//     This will print a table with 3 columns and 4 rows. In this example, it
+//     is required that data is defined as char[3][25][kMaxStringLength] to
+//     properly print.
+//
+// op        cycles    cpu %
+// -------------------------
+// foo     | 1000     | 10
+// bar     | 2500     | 25
+// baz     | 1000     | 10
+// lorem   | 2000     | 20
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+template <int kMaxRows, int kColumns>
+void PrintTable(const char headers[kColumns][kMaxStringLength],
+                const char data[kColumns][kMaxRows][kMaxStringLength],
+                const int rows) {
+  // Get the maximum width for each column in the table.
+  int max_column_width[kColumns];
+  for (int i = 0; i < kColumns; ++i) {
+    max_column_width[i] = std::max(GetLongestStringLength(data[i], rows),
+                                   static_cast<int>(strlen(headers[i])));
+  }
+
+  // Add padding between each item in the header so it can be printed on one
+  // line.
+  char header_spaces[kColumns][kMaxStringLength];
+  for (int i = 0; i < kColumns; ++i) {
+    FillColumnPadding(header_spaces[i], strlen(headers[i]), max_column_width[i],
+                      kDefaultColumnPadding + 2);
+  }
+
+  // Print the header.
+  char header[kMaxRowLength];
+  memset(header, 0, kMaxRowLength);
+  for (int i = 0; i < kColumns; ++i) {
+    MicroStrcat(header, headers[i]);
+    MicroStrcat(header, header_spaces[i]);
+  }
+  MicroPrintf("%s", header);
+
+  // Print a separator to separate the header from the data.
+  char separator[kMaxRowLength];
+  FillString(separator, strlen(header) - 1, kMaxRowLength, '-');
+  MicroPrintf("%s", separator);
+
+  for (int i = 0; i < rows; ++i) {
+    char spaces[kColumns][kMaxStringLength];
+    for (int j = 0; j < kColumns; ++j) {
+      FillColumnPadding(spaces[j], strlen(data[j][i]), max_column_width[j]);
+    }
+
+    char row[kMaxRowLength];
+    memset(row, 0, kMaxRowLength);
+
+    // Concatenate each column in a row with the format "[data][padding]| "
+    for (int j = 0; j < kColumns; ++j) {
+      MicroStrcat(row, data[j][i]);
+      MicroStrcat(row, spaces[j]);
+      MicroStrcat(row, "| ");
+    }
+
+    MicroPrintf("%s", row);
+  }
+
+  MicroPrintf(separator);
+  MicroPrintf("");
+}
+
+// Pretty prints a csv to stdout.
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex)
+// op,cycles,%cpu
+// foo,1000,10
+// bar,2500,25
+// baz,1000,10
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+template <int kMaxRows, int kColumns>
+void PrintCsv(const char headers[kColumns][kMaxStringLength],
+              const char data[kColumns][kMaxRows][kMaxStringLength],
+              const int rows) {
+  char header[kMaxRowLength];
+  memset(header, 0, kMaxRowLength);
+  for (int i = 0; i < kColumns; ++i) {
+    MicroStrcat(header, headers[i]);
+    if (i < kColumns - 1) {
+      MicroStrcat(header, ",");
+    }
+  }
+
+  MicroPrintf("%s", header);
+
+  char row[kMaxRowLength];
+  for (int i = 0; i < rows; ++i) {
+    memset(row, 0, kMaxRowLength);
+    for (int j = 0; j < kColumns; ++j) {
+      MicroStrcat(row, data[j][i]);
+      if (j < kColumns - 1) {
+        MicroStrcat(row, ",");
+      }
+    }
+
+    MicroPrintf("%s", row);
+  }
+
+  MicroPrintf("");  // Serves as a new line.
+}
+
+// Prints a 2D array of strings in a formatted manner along with a table name
+// that includes the table type.
+//
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex) PrettyPrint::kCsv will print a csv with a [[ CSV ]]: table_name header.
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+// - type: The format type that should be used to pretty print.
+// - table_name: The name of the table to be printed alongside the format type.
+template <int kMaxRows, int kColumns>
+void PrintFormattedData(const char headers[kColumns][kMaxStringLength],
+                        const char data[kColumns][kMaxRows][kMaxStringLength],
+                        const int rows, const PrettyPrintType type,
+                        const char* table_name) {
+  PrettyPrintTableHeader(type, table_name);
+  switch (type) {
+    case PrettyPrintType::kCsv:
+      PrintCsv<kMaxRows, kColumns>(headers, data, rows);
+      break;
+    case PrettyPrintType::kTable:
+      PrintTable<kMaxRows, kColumns>(headers, data, rows);
+      break;
+  }
+}
+
+}  // namespace tflite
+
+#endif  // TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tools/benchmarking/metrics.h

@@ -0,0 +1,41 @@
+/* Copyright 2023 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 TFLM_BENCHMARK_INTERNAL_METRICS_H_
+#define TFLM_BENCHMARK_INTERNAL_METRICS_H_
+
+#include <stdio.h>
+
+#include <cmath>
+#include <cstdint>
+
+#include "tensorflow/lite/micro/micro_profiler.h"
+#include "tensorflow/lite/micro/recording_micro_allocator.h"
+#include "tensorflow/lite/micro/tools/benchmarking/log_utils.h"
+
+namespace tflite {
+
+// Logs the allocation events. Prints out two tables, one for the arena
+// allocations, and one for each type of TFLM allocation type.
+// Args:
+//   - allocator: The recording micro allocator used during the invocation
+//       process.
+//   - type: Which print format should be used to output the allocation data to
+//       stdout.
+void LogAllocatorEvents(const tflite::RecordingMicroAllocator& allocator,
+                        PrettyPrintType type);
+}  // namespace tflite
+
+#endif  // TFLM_BENCHMARK_INTERNAL_METRICS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tools/benchmarking/op_resolver.h

@@ -0,0 +1,127 @@
+/* Copyright 2023 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 TFLM_BENCHMARK_OP_RESOLVER_H_
+#define TFLM_BENCHMARK_OP_RESOLVER_H_
+
+#include <memory>
+
+#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
+#include "tensorflow/lite/micro/micro_op_resolver.h"
+
+namespace tflite {
+
+inline TfLiteStatus CreateOpResolver(
+    tflite::MicroMutableOpResolver<96>& op_resolver) {
+  TF_LITE_ENSURE_STATUS(op_resolver.AddFullyConnected());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddAdd());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddAbs());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddAddN());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddArgMax());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddArgMin());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddAssignVariable());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddBatchToSpaceNd());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddBroadcastArgs());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddBroadcastTo());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCallOnce());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCast());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCeil());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCircularBuffer());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddConcatenation());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCos());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddCumSum());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddDepthToSpace());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddDequantize());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddDiv());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddElu());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddEqual());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddEthosU());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddExp());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddExpandDims());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddFill());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddFloor());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddFloorDiv());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddFloorMod());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddGather());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddGatherNd());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddGreater());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddGreaterEqual());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddHardSwish());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddIf());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddL2Normalization());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddL2Pool2D());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLeakyRelu());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLess());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLessEqual());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLog());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLogicalAnd());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLogicalNot());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLogicalOr());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLogistic());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddLogSoftmax());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMaximum());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMirrorPad());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMean());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMinimum());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddNeg());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddNotEqual());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddPack());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddPadV2());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddPrelu());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddQuantize());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddReadVariable());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddReduceMax());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddRelu());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddRelu6());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddReshape());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddResizeBilinear());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddResizeNearestNeighbor());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddRound());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddRsqrt());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSelectV2());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddShape());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSin());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSlice());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSoftmax());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSpaceToBatchNd());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSpaceToDepth());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSplit());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSplitV());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSqueeze());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSqrt());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSquare());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSquaredDifference());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddStridedSlice());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSub());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSum());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddSvdf());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddTanh());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddTransposeConv());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddTranspose());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddUnpack());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddUnidirectionalSequenceLSTM());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddVarHandle());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddWhile());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddZerosLike());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddDepthwiseConv2D());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddConv2D());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddAveragePool2D());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddPad());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMaxPool2D());
+  TF_LITE_ENSURE_STATUS(op_resolver.AddMul());
+  return kTfLiteOk;
+}
+}  // namespace tflite
+#endif  // TFLM_BENCHMARK_OP_RESOLVER_H_