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/kernels/internal/tensor_ctypes.h

@@ -15,7 +15,10 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_KERNELS_INTERNAL_TENSOR_CTYPES_H_
 #define TENSORFLOW_LITE_KERNELS_INTERNAL_TENSOR_CTYPES_H_
 
+#include <vector>
+
 #include "tensorflow/lite/core/c/common.h"
+#include "tensorflow/lite/core/macros.h"
 #include "tensorflow/lite/kernels/internal/types.h"
 
 namespace tflite {
@@ -31,16 +34,8 @@ inline const T* GetTensorData(const TfLiteTensor* tensor) {
                            : nullptr;
 }
 
-inline RuntimeShape GetTensorShape(const TfLiteTensor* tensor) {
-  if (tensor == nullptr) {
-    return RuntimeShape();
-  }
-
-  TfLiteIntArray* dims = tensor->dims;
-  const int dims_size = dims->size;
-  const int32_t* dims_data = reinterpret_cast<const int32_t*>(dims->data);
-  return RuntimeShape(dims_size, dims_data);
-}
+TFLITE_NOINLINE RuntimeShape GetTensorShape(const TfLiteTensor* tensor);
+RuntimeShape GetTensorShape(std::vector<int32_t> data);
 
 }  // namespace tflite
 

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/types.h

@@ -157,7 +157,8 @@ struct PerChannelQuantizationParams {
 };
 
 // Gets next index to iterate through a multidimensional array.
-inline bool NextIndex(const int num_dims, const int* dims, int* current) {
+template <typename IndexType = int>
+inline bool NextIndex(const int num_dims, const int* dims, IndexType* current) {
   if (num_dims == 0) {
     return false;
   }
@@ -165,7 +166,7 @@ inline bool NextIndex(const int num_dims, const int* dims, int* current) {
   TFLITE_DCHECK(current != nullptr);
   int carry = 1;
   for (int idx = num_dims - 1; idx >= 0; --idx) {
-    int current_val = current[idx] + carry;
+    IndexType current_val = current[idx] + carry;
     TFLITE_DCHECK_GE(dims[idx], current_val);
     if (dims[idx] == current_val) {
       current[idx] = 0;
@@ -982,6 +983,7 @@ struct StridedSliceParams {
   uint16_t end_mask;
   uint16_t new_axis_mask;
   uint16_t shrink_axis_mask;
+  bool offset;
 };
 
 struct TanhParams {

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/kernel_util.h

@@ -24,6 +24,9 @@ limitations under the License.
 
 #include "tensorflow/lite/core/c/builtin_op_data.h"
 #include "tensorflow/lite/core/c/common.h"
+#ifndef NDEBUG
+#include "tensorflow/lite/kernels/op_macros.h"
+#endif
 
 namespace tflite {
 
@@ -165,24 +168,31 @@ inline int NumIntermediates(const TfLiteNode* node) {
 }
 #endif  // TF_LITE_STATIC_MEMORY
 
-inline int64_t NumElements(const TfLiteIntArray* dims) {
+inline int64_t NumElements(const int* dims, int num_dims) {
   int64_t count = 1;
-  for (int i = 0; i < dims->size; ++i) {
-    count *= dims->data[i];
+  for (int i = 0; i < num_dims; ++i) {
+#ifndef NDEBUG
+    if (count <= 0) {
+      break;
+    }
+    // Check that number of elements can fit in 32 bit int. Most of tflite
+    // assumes the result of `NumElements` is < MAX_INT and static or implicit
+    // casts to `int32_t` without any checks. It is more meaningful to check
+    // that the result fits into 32 bits than for standard overflow on 64 bit
+    // type.
+    TF_LITE_ASSERT(dims[i] < std::numeric_limits<int>::max() / count);
+#endif
+    count *= dims[i];
   }
   return count;
 }
 
-inline int64_t NumElements(const TfLiteTensor* t) {
-  return NumElements(t->dims);
+inline int64_t NumElements(const TfLiteIntArray* dims) {
+  return NumElements(dims->data, dims->size);
 }
 
-inline int64_t NumElements(const int* dims, int num_dims) {
-  int64_t count = 1;
-  for (int i = 0; i < num_dims; ++i) {
-    count *= dims[i];
-  }
-  return count;
+inline int64_t NumElements(const TfLiteTensor* t) {
+  return NumElements(t->dims);
 }
 
 // Determines whether tensor is constant.
@@ -204,22 +214,23 @@ inline bool IsConstantOrPersistentTensor(const TfLiteTensor* tensor) {
 inline bool IsDynamicTensor(const TfLiteTensor* tensor) {
   return tensor->allocation_type == kTfLiteDynamic;
 }
-
+#ifndef TF_LITE_STATIC_MEMORY
 // Sets tensor to dynamic.
 inline void SetTensorToDynamic(TfLiteTensor* tensor) {
   if (tensor->allocation_type != kTfLiteDynamic) {
+    TfLiteTensorDataFree(tensor);
     tensor->allocation_type = kTfLiteDynamic;
-    tensor->data.raw = nullptr;
   }
 }
 
 // Sets tensor to persistent and read-only.
 inline void SetTensorToPersistentRo(TfLiteTensor* tensor) {
   if (tensor->allocation_type != kTfLitePersistentRo) {
+    TfLiteTensorDataFree(tensor);
     tensor->allocation_type = kTfLitePersistentRo;
-    tensor->data.raw = nullptr;
   }
 }
+#endif  // TF_LITE_STATIC_MEMORY
 
 // Determines whether it is a hybrid op - one that has float inputs and
 // quantized weights.

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/op_macros.h

@@ -1,4 +1,4 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+/* 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.
@@ -15,14 +15,14 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_KERNELS_OP_MACROS_H_
 #define TENSORFLOW_LITE_KERNELS_OP_MACROS_H_
 
-#include "tensorflow/lite/micro/debug_log.h"
+#include "tensorflow/lite/micro/micro_log.h"
 
 #if !defined(TF_LITE_MCU_DEBUG_LOG)
 #include <cstdlib>
 #define TFLITE_ABORT abort()
 #else
 inline void AbortImpl() {
-  DebugLog("HALTED\n");
+  MicroPrintf("HALTED");
   while (1) {
   }
 }
@@ -35,4 +35,15 @@ inline void AbortImpl() {
 #define TFLITE_ASSERT_FALSE TFLITE_ABORT
 #endif
 
+#define TF_LITE_FATAL(msg)    \
+  do {                        \
+    MicroPrintf("%s", (msg)); \
+    TFLITE_ABORT;             \
+  } while (0)
+
+#define TF_LITE_ASSERT(x)        \
+  do {                           \
+    if (!(x)) TF_LITE_FATAL(#x); \
+  } while (0)
+
 #endif  // TENSORFLOW_LITE_KERNELS_OP_MACROS_H_

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

@@ -1,4 +1,4 @@
-/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+/* 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.
@@ -15,14 +15,21 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_MICRO_DEBUG_LOG_H_
 #define TENSORFLOW_LITE_MICRO_DEBUG_LOG_H_
 
+#ifdef __cplusplus
+#include <cstdarg>
+#else
+#include <stdarg.h>
+#endif  // __cplusplus
+
 #ifdef __cplusplus
 extern "C" {
 #endif  // __cplusplus
 
 // This function should be implemented by each target platform, and provide a
 // way for strings to be output to some text stream. For more information, see
-// tensorflow/lite/micro/debug_log.cc.
-void DebugLog(const char* s);
+// the tensorflow/lite/micro/debug_log.cc file.  This function should support
+// standard C/C++ stdio style formatting operations.
+void DebugLog(const char* format, va_list args);
 
 #ifdef __cplusplus
 }  // extern "C"

xmos_ai_tools/runtime/include/tensorflow/lite/micro/examples/micro_speech/micro_model_settings.h

@@ -0,0 +1,37 @@
+/* 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_EXAMPLES_MICRO_SPEECH_MICRO_MODEL_SETTINGS_H_
+#define TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_MODEL_SETTINGS_H_
+
+// The following values are derived from values used during model training.
+// If you change the way you preprocess the input, update all these constants.
+constexpr int kAudioSampleFrequency = 16000;
+constexpr int kFeatureSize = 40;
+constexpr int kFeatureCount = 49;
+constexpr int kFeatureElementCount = (kFeatureSize * kFeatureCount);
+constexpr int kFeatureStrideMs = 20;
+constexpr int kFeatureDurationMs = 30;
+
+// Variables for the model's output categories.
+constexpr int kCategoryCount = 4;
+constexpr const char* kCategoryLabels[kCategoryCount] = {
+    "silence",
+    "unknown",
+    "yes",
+    "no",
+};
+
+#endif  // TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_MODEL_SETTINGS_H_

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

@@ -27,6 +27,8 @@ namespace tflite {
 
 class FakeMicroContext : public MicroContext {
  public:
+  ~FakeMicroContext() = default;
+
   FakeMicroContext(TfLiteTensor* tensors, SingleArenaBufferAllocator* allocator,
                    MicroGraph* micro_graph);
 
@@ -44,9 +46,14 @@ class FakeMicroContext : public MicroContext {
 
   TfLiteEvalTensor* GetEvalTensor(int tensor_index) override;
 
+  TfLiteStatus set_external_context(void* external_context_payload) override;
+  void* external_context() override;
+  MicroGraph& graph() override;
+
  private:
   static constexpr int kNumScratchBuffers_ = 12;
 
+  MicroGraph& graph_;
   int scratch_buffer_count_ = 0;
   uint8_t* scratch_buffers_[kNumScratchBuffers_];
 

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/add.h

@@ -20,6 +20,7 @@ limitations under the License.
 
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_common.h"
 
 namespace tflite {
 
@@ -60,17 +61,17 @@ TfLiteStatus CalculateOpDataAdd(TfLiteContext* context, TfLiteAddParams* params,
 TfLiteStatus AddPrepare(TfLiteContext* context, TfLiteNode* node);
 
 // Generic must define registration function.
-TfLiteRegistration_V1 Register_ADD();
+TFLMRegistration Register_ADD();
 
 #if defined(CMSIS_NN)
-TfLiteRegistration_V1 Register_ADD_INT8();
+TFLMRegistration Register_ADD_INT8();
 
-TfLiteRegistration_V1 Register_ADD_INT16();
+TFLMRegistration Register_ADD_INT16();
 #else
 // Fallback registration
-inline TfLiteRegistration_V1 Register_ADD_INT8() { return Register_ADD(); }
+inline TFLMRegistration Register_ADD_INT8() { return Register_ADD(); }
 
-inline TfLiteRegistration_V1 Register_ADD_INT16() { return Register_ADD(); }
+inline TFLMRegistration Register_ADD_INT16() { return Register_ADD(); }
 #endif
 }  // namespace tflite
 

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/circular_buffer.h

@@ -30,9 +30,6 @@ extern const int kCircularBufferOutputTensor;
 // Elements in the vectors are ordered alphabetically by parameter name.
 extern const int kCircularBufferCyclesMaxIndex;  // 'cycles_max'
 
-// TODO(b/149795762): Add this to TfLiteStatus enum.
-extern const TfLiteStatus kTfLiteAbort;
-
 // These fields control the stride period of a strided streaming model. This op
 // returns kTfLiteAbort until cycles_until_run-- is zero.  At this time,
 // cycles_until_run is reset to cycles_max.

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/conv.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+/* 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.
@@ -19,8 +19,8 @@ limitations under the License.
 #include <cstdint>
 
 #include "tensorflow/lite/c/builtin_op_data.h"
-#include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/types.h"
+#include "tensorflow/lite/micro/micro_common.h"
 
 namespace tflite {
 
@@ -74,44 +74,43 @@ TfLiteStatus CalculateOpDataConv(TfLiteContext* context, TfLiteNode* node,
                                  int out_height, const TfLiteType data_type,
                                  OpDataConv* data);
 
+void* ConvInit(TfLiteContext* context, const char* buffer, size_t length);
+
 TfLiteStatus ConvPrepare(TfLiteContext* context, TfLiteNode* node);
 
-// This is the most generic TfLiteRegistration_V1. The actual supported types
+// This is the most generic TFLMRegistration. The actual supported types
 // may still be target dependent. The only requirement is that every
 // implementation (reference or optimized) must define this function.
-TfLiteRegistration_V1 Register_CONV_2D();
+TFLMRegistration Register_CONV_2D();
 
 #if defined(XTENSA)
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int8 activations and int8 weights and always calls the reference
 // implementation.
-TfLiteRegistration_V1 Register_CONV_2D_INT8REF();
+TFLMRegistration Register_CONV_2D_INT8REF();
+
 #else
-inline TfLiteRegistration_V1 Register_CONV_2D_INT8REF() {
+inline TFLMRegistration Register_CONV_2D_INT8REF() {
   return Register_CONV_2D();
 }
-#endif
+#endif  // defined(XTENSA)
 
-#if defined(CMSIS_NN)
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+#if defined(CMSIS_NN) || defined(XTENSA)
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int8 activations and int8 weights and uses the latency optimized
 // implementations.
-TfLiteRegistration_V1 Register_CONV_2D_INT8();
+TFLMRegistration Register_CONV_2D_INT8();
 
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int16 activations and int8 weights and uses the latency optimized
 // implementations.
-TfLiteRegistration_V1 Register_CONV_2D_INT16();
+TFLMRegistration Register_CONV_2D_INT16();
 
 #else
-inline TfLiteRegistration_V1 Register_CONV_2D_INT8() {
-  return Register_CONV_2D();
-}
+inline TFLMRegistration Register_CONV_2D_INT8() { return Register_CONV_2D(); }
 
-inline TfLiteRegistration_V1 Register_CONV_2D_INT16() {
-  return Register_CONV_2D();
-}
-#endif
+inline TFLMRegistration Register_CONV_2D_INT16() { return Register_CONV_2D(); }
+#endif  // defined(CMSIS_NN) || defined(XTENSA)
 
 }  // namespace tflite
 

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/conv_test.h

@@ -28,56 +28,33 @@ namespace testing {
 
 TfLiteStatus InvokeConv(TfLiteTensor* tensors, int tensors_size,
                         int output_length, TfLiteConvParams* conv_params,
-                        TfLiteRegistration_V1 registration, float* output_data);
+                        TFLMRegistration registration, float* output_data);
 
 TfLiteStatus InvokeConv(TfLiteTensor* tensors, int tensors_size,
                         int output_length, TfLiteConvParams* conv_params,
-                        TfLiteRegistration_V1 registration,
-                        int8_t* output_data);
-
-TfLiteStatus InvokeConv(TfLiteTensor* tensors, int tensors_size,
-                        int output_length, TfLiteConvParams* conv_params,
-                        TfLiteRegistration_V1 registration,
-                        uint8_t* output_data);
+                        TFLMRegistration registration, int8_t* output_data);
 
 TfLiteStatus ValidateConvGoldens(TfLiteTensor* tensors, int tensors_size,
                                  const float* expected_output_data,
                                  int output_length,
                                  TfLiteConvParams* conv_params,
-                                 TfLiteRegistration_V1 registration,
+                                 TFLMRegistration registration,
                                  float* output_data, float tolerance = 1e-5);
 
 TfLiteStatus ValidateConvGoldens(TfLiteTensor* tensors, int tensors_size,
                                  const int8_t* expected_output_data,
                                  int output_length,
                                  TfLiteConvParams* conv_params,
-                                 TfLiteRegistration_V1 registration,
+                                 TFLMRegistration registration,
                                  int8_t* output_data, float tolerance = 1e-5);
 
-TfLiteStatus ValidateConvGoldens(TfLiteTensor* tensors, int tensors_size,
-                                 const uint8_t* expected_output_data,
-                                 int output_length,
-                                 TfLiteConvParams* conv_params,
-                                 TfLiteRegistration_V1 registration,
-                                 uint8_t* output_data, float tolerance = 1e-5);
-
 TfLiteStatus TestConvFloat(int* input_dims_data, const float* input_data,
                            int* filter_dims_data, const float* filter_data,
                            int* bias_dims_data, const float* bias_data,
                            int* output_dims_data,
                            const float* expected_output_data,
                            TfLiteConvParams* conv_params,
-                           TfLiteRegistration_V1 registration,
-                           float* output_data);
-
-TfLiteStatus TestConvQuantizedPerLayer(
-    int* input_dims_data, const float* input_data, uint8_t* input_quantized,
-    float input_scale, int* filter_dims_data, const float* filter_data,
-    uint8_t* filter_quantized, float filter_scale, int* bias_dims_data,
-    const float* bias_data, int32_t* bias_quantized, int* output_dims_data,
-    const float* expected_output_data, uint8_t* expected_output_quantized,
-    float output_scale, TfLiteConvParams* conv_params,
-    TfLiteRegistration_V1 registration, uint8_t* output_data);
+                           TFLMRegistration registration, float* output_data);
 
 TfLiteStatus TestConvQuantizedPerChannel(
     int* input_dims_data, const float* input_data, int8_t* input_quantized,
@@ -87,7 +64,7 @@ TfLiteStatus TestConvQuantizedPerChannel(
     float* bias_scales, int* bias_zero_points, int* output_dims_data,
     const float* expected_output_data, int8_t* expected_output_data_quantized,
     float output_scale, int output_zero_point, TfLiteConvParams* conv_params,
-    TfLiteRegistration_V1 registration, int8_t* output_data,
+    TFLMRegistration registration, int8_t* output_data,
     TfLiteType tensor_weight_type = kTfLiteNoType);
 
 TfLiteStatus TestConvQuantizedPerChannel(
@@ -99,7 +76,7 @@ TfLiteStatus TestConvQuantizedPerChannel(
     int* bias_zero_points, int* output_dims_data,
     const float* expected_output_data, int16_t* expected_output_data_quantized,
     float output_scale, int output_zero_point, TfLiteConvParams* conv_params,
-    TfLiteRegistration_V1 registration, int16_t* output_data);
+    TFLMRegistration registration, int16_t* output_data);
 
 TfLiteStatus TestConvQuantizedPerChannel(
     int* input_dims_data, const float* input_data, int16_t* input_quantized,
@@ -109,7 +86,7 @@ TfLiteStatus TestConvQuantizedPerChannel(
     float* bias_scales, int* bias_zero_points, int* output_dims_data,
     const float* expected_output_data, int16_t* expected_output_data_quantized,
     float output_scale, int output_zero_point, TfLiteConvParams* conv_params,
-    TfLiteRegistration_V1 registration, int16_t* output_data);
+    TFLMRegistration registration, int16_t* output_data);
 
 }  // namespace testing
 }  // namespace tflite

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/depthwise_conv.h

@@ -49,28 +49,28 @@ TfLiteStatus CalculateOpDataDepthwiseConv(
 
 TfLiteStatus DepthwiseConvPrepare(TfLiteContext* context, TfLiteNode* node);
 
-// This is the most generic TfLiteRegistration_V1. The actual supported types
+// This is the most generic TFLMRegistration. The actual supported types
 // may still be target dependent. The only requirement is that every
 // implementation (reference or optimized) must define this function.
-TfLiteRegistration_V1 Register_DEPTHWISE_CONV_2D();
+TFLMRegistration Register_DEPTHWISE_CONV_2D();
 
 #if defined(CMSIS_NN)
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int8 activations and int8 weights and uses the latency optimized
 // implementations.
-TfLiteRegistration_V1 Register_DEPTHWISE_CONV_2D_INT8();
+TFLMRegistration Register_DEPTHWISE_CONV_2D_INT8();
 
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int16 activations and int8 weights and uses the latency optimized
 // implementations.
-TfLiteRegistration_V1 Register_DEPTHWISE_CONV_2D_INT16();
+TFLMRegistration Register_DEPTHWISE_CONV_2D_INT16();
 
 #else
-inline TfLiteRegistration_V1 Register_DEPTHWISE_CONV_2D_INT8() {
+inline TFLMRegistration Register_DEPTHWISE_CONV_2D_INT8() {
   return Register_DEPTHWISE_CONV_2D();
 }
 
-inline TfLiteRegistration_V1 Register_DEPTHWISE_CONV_2D_INT16() {
+inline TFLMRegistration Register_DEPTHWISE_CONV_2D_INT16() {
   return Register_DEPTHWISE_CONV_2D();
 }
 #endif

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/ethosu.h

@@ -19,7 +19,7 @@ limitations under the License.
 
 namespace tflite {
 
-TfLiteRegistration_V1* Register_ETHOSU();
+TFLMRegistration* Register_ETHOSU();
 
 const char* GetString_ETHOSU();
 

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/fully_connected.h

@@ -18,8 +18,8 @@ limitations under the License.
 #include <cstdint>
 
 #include "tensorflow/lite/c/builtin_op_data.h"
-#include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/types.h"
+#include "tensorflow/lite/micro/micro_common.h"
 
 namespace tflite {
 
@@ -68,15 +68,15 @@ TfLiteStatus CalculateOpDataFullyConnected(
     TfLiteType data_type, const TfLiteTensor* input, const TfLiteTensor* filter,
     const TfLiteTensor* bias, TfLiteTensor* output, OpDataFullyConnected* data);
 
-// This is the most generic TfLiteRegistration_V1. The actual supported types
+// This is the most generic TFLMRegistration. The actual supported types
 // may still be target dependent. The only requirement is that every
 // implementation (reference or optimized) must define this function.
-TfLiteRegistration_V1 Register_FULLY_CONNECTED();
+TFLMRegistration Register_FULLY_CONNECTED();
 
 #if defined(CMSIS_NN) || defined(HEXAGON) || defined(XTENSA)
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int8.
-TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT8();
+TFLMRegistration Register_FULLY_CONNECTED_INT8();
 
 #else
 // Note that while this block gets used for both reference and optimized kernels
@@ -84,16 +84,16 @@ TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT8();
 // define fallback implementation that allow reference kernels to still be used
 // from applications that call a more specific kernel variant.
 
-inline TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT8() {
+inline TFLMRegistration Register_FULLY_CONNECTED_INT8() {
   return Register_FULLY_CONNECTED();
 }
 
 #endif
 
 #if defined(CMSIS_NN)
-// Returns a TfLiteRegistration_V1 struct for kernel variant that only supports
+// Returns a TFLMRegistration struct for kernel variant that only supports
 // int16.
-TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT16();
+TFLMRegistration Register_FULLY_CONNECTED_INT16();
 
 #else
 // Note that while this block gets used for both reference and optimized kernels
@@ -101,7 +101,7 @@ TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT16();
 // define fallback implementation that allow reference kernels to still be used
 // from applications that call a more specific kernel variant.
 
-inline TfLiteRegistration_V1 Register_FULLY_CONNECTED_INT16() {
+inline TFLMRegistration Register_FULLY_CONNECTED_INT16() {
   return Register_FULLY_CONNECTED();
 }
 

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/kernel_runner.h

@@ -25,7 +25,7 @@ limitations under the License.
 namespace tflite {
 namespace micro {
 
-// Helper class to perform a simulated kernel (i.e. TfLiteRegistration_V1)
+// Helper class to perform a simulated kernel (i.e. TFLMRegistration)
 // lifecycle (init, prepare, invoke). All internal allocations are handled by
 // this class. Simply pass in the registration, list of required tensors, inputs
 // array, outputs array, and any pre-builtin data. Calling Invoke() will
@@ -33,26 +33,31 @@ namespace micro {
 // output provided during construction.
 class KernelRunner {
  public:
-  KernelRunner(const TfLiteRegistration_V1& registration, TfLiteTensor* tensors,
+  KernelRunner(const TFLMRegistration& registration, TfLiteTensor* tensors,
                int tensors_size, TfLiteIntArray* inputs,
-               TfLiteIntArray* outputs, void* builtin_data,
+               TfLiteIntArray* outputs, const void* builtin_data,
                TfLiteIntArray* intermediates = nullptr);
 
-  // Calls init and prepare on the kernel (i.e. TfLiteRegistration_V1) struct.
+  // Calls init and prepare on the kernel (i.e. TFLMRegistration) struct.
   // Any exceptions will be DebugLog'd and returned as a status code.
   TfLiteStatus InitAndPrepare(const char* init_data = nullptr,
                               size_t length = 0);
 
-  // Calls init, prepare, and invoke on a given TfLiteRegistration_V1 pointer.
-  // After successful invoke, results will be available in the output tensor as
-  // passed into the constructor of this class.
+  // Calls invoke on a given TFLMRegistration pointer. After successful
+  // invoke, results will be available in the output tensor as passed into the
+  // constructor of this class.
   TfLiteStatus Invoke();
 
-  // Calls Free on a given TfLiteRegistration_V1 pointer(if it's implemented).
+  // Calls Free on a given TFLMRegistration pointer(if it's implemented).
   // After successful Free, kTfLiteOk status will be returned. If Free is not
   // implemented for a given kernel kTfLiteError will be returned.
   TfLiteStatus Free();
 
+  // Calls Reset on a given TFLMRegistration pointer(if it's implemented).
+  // After successful Reset, kTfLiteOk status will be returned. If Free is not
+  // implemented for a given kernel kTfLiteError will be returned.
+  TfLiteStatus Reset();
+
   // Returns a pointer to the internal MockMicroGraph which KernelRunner uses
   // to stub out MicroGraph methods and track invocations on each subgraph.
   MockMicroGraph* GetMockGraph() { return &mock_micro_graph_; }
@@ -68,7 +73,7 @@ class KernelRunner {
 
   TfLiteContext context_ = {};
   TfLiteNode node_ = {};
-  const TfLiteRegistration_V1& registration_;
+  const TFLMRegistration& registration_;
 
   SingleArenaBufferAllocator* allocator_;
   MockMicroGraph mock_micro_graph_;