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/micro_interpreter_context.h

@@ -0,0 +1,125 @@
+/* Copyright 2021 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_MICRO_INTERPRETER_CONTEXT_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_CONTEXT_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_context.h"
+#include "tensorflow/lite/micro/micro_interpreter_graph.h"
+#include "tensorflow/lite/micro/micro_log.h"
+
+namespace tflite {
+
+// A full implementation of the MicroContext, to be used by the
+// MicroInterpreter. Kernels should not depend on this directly. Instead they
+// should only depend on the MicroContext.
+class MicroInterpreterContext : public MicroContext {
+ public:
+  // Enum that allows MicroContext to keep track of the stages different memory
+  // planning APIs are available to kernels.
+  enum class InterpreterState {
+    kInit,
+    kPrepare,
+    kMemoryPlanning,
+    kInvoke,
+  };
+
+  // Does not take any ownership, and all pointers must refer to valid objects
+  // that outlive the one constructed.
+  MicroInterpreterContext(MicroAllocator* allocator, const Model* model,
+                          MicroInterpreterGraph* graph);
+  virtual ~MicroInterpreterContext();
+
+  // Allocate persistent buffer which has the same life time as the interpreter.
+  // Returns nullptr on failure.
+  // The memory is allocated from the tail.
+  // This method is only available in Init or Prepare stage.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void* AllocatePersistentBuffer(size_t bytes) override;
+
+  // Request a scratch buffer in the arena through static memory planning.
+  // This method is only available in Prepare stage and the buffer is allocated
+  // by the interpreter between Prepare and Eval stage. In Eval stage,
+  // GetScratchBuffer API can be used to fetch the address.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteStatus RequestScratchBufferInArena(size_t bytes,
+                                                   int* buffer_idx) override;
+
+  // Get the scratch buffer pointer.
+  // This method is only available in Eval stage.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void* GetScratchBuffer(int buffer_idx) override;
+
+  // Returns a temporary TfLiteTensor struct for a given index.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteTensor* AllocateTempTfLiteTensor(int tensor_idx) override;
+  virtual TfLiteTensor* AllocateTempTfLiteTensor(int tensor_idx, int sg) override;
+
+  // Deallocates a temp TfLiteTensor.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void DeallocateTempTfLiteTensor(TfLiteTensor* tensor) override;
+
+  // Returns a pointer to a temporary buffer (from the arena).
+  // This API is only valid from the kernel's Prepare function and
+  // the buffer's lifetime is also that of the Prepare function.
+  // Virtual so that it can be faked for kernel tests.
+  virtual uint8_t* AllocateTempBuffer(size_t size, size_t alignment) override;
+
+  // Signals that the temporary buffer is no longer needed.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void DeallocateTempBuffer(uint8_t* buffer) override;
+
+  // Returns a TfLiteEvalTensor struct for a given index.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteEvalTensor* GetEvalTensor(int tensor_idx) override;
+  virtual TfLiteEvalTensor* GetEvalTensor(int tensor_idx, int sg) override;
+
+  // Sets the State of MemoryPlanning MicroInterpreterContext
+  void SetInterpreterState(InterpreterState state);
+
+  // Sets the State of MemoryPlanning MicroInterpreterContext
+  InterpreterState GetInterpreterState() const;
+
+  // Does not take ownership of the pointer and the pointer must refer to valid
+  // an object that outlive this class instance.
+  // This can only be called once to set one external context.
+  TfLiteStatus set_external_context(void* external_context_payload) override;
+
+  void* external_context() override { return external_context_payload_; }
+
+  MicroGraph& graph() override { return graph_; }
+
+  // Sets the pointer to a list of ScratchBufferHandle instances.
+  // Not API between TFLM and kernels. Primarily used by the framework for
+  // housekeeping in MicroInterpreterContext.
+  void SetScratchBufferHandles(ScratchBufferHandle* scratch_buffer_handles);
+
+ private:
+  MicroAllocator& allocator_;
+  MicroInterpreterGraph& graph_;
+  const Model* model_;
+  InterpreterState state_;
+
+  ScratchBufferHandle* scratch_buffer_handles_ = nullptr;
+  void* external_context_payload_ = nullptr;
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_CONTEXT_H_

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

@@ -0,0 +1,110 @@
+/* Copyright 2021 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_MICRO_INTERPRETER_GRAPH_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_GRAPH_H_
+
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_common.h"
+#include "tensorflow/lite/micro/micro_graph.h"
+#include "tensorflow/lite/micro/micro_resource_variable.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite {
+
+// Abstracts the details of interacting with the tflite::Model.
+//
+// Provides methods to access, initialize, prepare, invoke and free any
+// subgraph in the tflite::Graph.
+class MicroInterpreterGraph : public MicroGraph {
+ public:
+  // The lifetime of the context, model, allocator and resource_variables must
+  // be at least as long as that of the graph object, since the this class may
+  // need to access them at any time. If resource_variables is a nullptr,
+  // GetResourceVariables will return a nullptr.
+  MicroInterpreterGraph(TfLiteContext* context, const Model* model,
+                        MicroAllocator* allocator,
+                        MicroResourceVariables* resource_variables);
+  virtual ~MicroInterpreterGraph();
+
+  // Sets up builtin data and calls TFLMRegistration->Init for every
+  // operator in every subgraph in the model.
+  virtual TfLiteStatus InitSubgraphs();
+
+  // Calls TFLMRegistration->Prepare for every operator in every subgraph
+  // in the model.
+  virtual TfLiteStatus PrepareSubgraphs();
+
+  // Calls TFLMRegistration->Reset for every operator in every subgraph in
+  // the model.
+  virtual TfLiteStatus ResetSubgraphs();
+
+  // Calls TFLMRegistration->Free for every operator in every subgraph in
+  // the model.
+  virtual TfLiteStatus FreeSubgraphs();
+
+  // Calls TFLMRegistration->Invoke for every operator in a single subgraph
+  // in the model.
+  virtual TfLiteStatus InvokeSubgraph(int subgraph_idx);
+
+  // Zeros out all variable tensors in all subgraphs in the model.
+  virtual TfLiteStatus ResetVariableTensors();
+
+  // Number of tensor inputs to a specified subgraph in the model.
+  virtual size_t NumSubgraphInputs(int subgraph_idx);
+
+  // Get the specified input tensor of a specified subgraph in the model.
+  virtual TfLiteEvalTensor* GetSubgraphInput(int subgraph_idx, int input_idx);
+
+  // Number of tensor outputs from a specified subgraph in the model.
+  virtual size_t NumSubgraphOutputs(int subgraph_idx);
+
+  // Get the specified output tensor of a specified subgraph in the model.
+  virtual TfLiteEvalTensor* GetSubgraphOutput(int subgraph_idx, int output_idx);
+
+  // Number of subgraphs in the model.
+  virtual int NumSubgraphs();
+
+  // Hook to pass in subgraph allocations tracked within the interpreter,
+  // allowing MicroInterpreterGraph to init / prepare / invoke subgraphs in the
+  // model.
+  void SetSubgraphAllocations(SubgraphAllocations* subgraph_allocations);
+
+  // Get the current subgraph index. Within an on operator, this is guaranteed
+  // to be the subgraph of that operator.
+  int GetCurrentSubgraphIndex() { return current_subgraph_index_; }
+
+  // Gets the list of alloctions for each subgraph. This is the source of truth
+  // for all per-subgraph allocation data.
+  SubgraphAllocations* GetAllocations() { return subgraph_allocations_; }
+
+  // Get the resource variables for this TFLM graph.
+  MicroResourceVariables* GetResourceVariables() { return resource_variables_; }
+
+ private:
+  TfLiteContext* context_;
+  const Model* model_;
+  MicroAllocator* allocator_;
+  SubgraphAllocations* subgraph_allocations_ = nullptr;
+  int current_subgraph_index_;
+  MicroResourceVariables* resource_variables_;
+  const flatbuffers::Vector<flatbuffers::Offset<SubGraph>>* subgraphs_;
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_GRAPH_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_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,20 +15,17 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_MICRO_MICRO_LOG_H_
 #define TENSORFLOW_LITE_MICRO_MICRO_LOG_H_
 
-#include <cstdarg>
-
-// This is a free function used to perform the actual logging.
-// This function will be used by MicroPrintf and MicroErrorReporter::Report()
-void Log(const char* format, va_list args);
-
 #if !defined(TF_LITE_STRIP_ERROR_STRINGS)
-// This function can be used independent of the MicroErrorReporter to get
+#include <cstdarg>
+// These functions can be used independent of the MicroErrorReporter to get
 // printf-like functionalitys and are common to all target platforms.
 void MicroPrintf(const char* format, ...);
+void VMicroPrintf(const char* format, va_list args);
 #else
 // We use a #define to ensure that the strings are completely stripped, to
 // prevent an unnecessary increase in the binary size.
 #define MicroPrintf(...) tflite::Unused(__VA_ARGS__)
+#define VMicroPrintf(...) tflite::Unused(__VA_ARGS__)
 #endif
 
 namespace tflite {
@@ -39,6 +36,7 @@ template <typename... Args>
 void Unused(Args&&... args) {
   (void)(sizeof...(args));
 }
+
 }  // namespace tflite
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_LOG_H_

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

@@ -37,7 +37,7 @@ limitations under the License.
 #include "tensorflow/lite/schema/schema_generated.h"
 
 namespace tflite {
-TfLiteRegistration_V1* Register_DETECTION_POSTPROCESS();
+TFLMRegistration* Register_DETECTION_POSTPROCESS();
 
 template <unsigned int tOpCount>
 class MicroMutableOpResolver : public MicroOpResolver {
@@ -46,12 +46,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   explicit MicroMutableOpResolver() {}
 
-  const TfLiteRegistration_V1* FindOp(
-      tflite::BuiltinOperator op) const override {
+  const TFLMRegistration* FindOp(tflite::BuiltinOperator op) const override {
     if (op == BuiltinOperator_CUSTOM) return nullptr;
 
     for (unsigned int i = 0; i < registrations_len_; ++i) {
-      const TfLiteRegistration_V1& registration = registrations_[i];
+      const TFLMRegistration& registration = registrations_[i];
       if (registration.builtin_code == op) {
         return &registration;
       }
@@ -59,9 +58,9 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return nullptr;
   }
 
-  const TfLiteRegistration_V1* FindOp(const char* op) const override {
+  const TFLMRegistration* FindOp(const char* op) const override {
     for (unsigned int i = 0; i < registrations_len_; ++i) {
-      const TfLiteRegistration_V1& registration = registrations_[i];
+      const TFLMRegistration& registration = registrations_[i];
       if ((registration.builtin_code == BuiltinOperator_CUSTOM) &&
           (strcmp(registration.custom_name, op) == 0)) {
         return &registration;
@@ -86,7 +85,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   // MicroOpResolver will be unchanged and this function will return
   // kTfLiteError.
   TfLiteStatus AddCustom(const char* name,
-                         TfLiteRegistration_V1* registration) {
+                         const TFLMRegistration* registration) {
     if (registrations_len_ >= tOpCount) {
       MicroPrintf(
           "Couldn't register custom op '%s', resolver size is too"
@@ -101,8 +100,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
       return kTfLiteError;
     }
 
-    TfLiteRegistration_V1* new_registration =
-        &registrations_[registrations_len_];
+    TFLMRegistration* new_registration = &registrations_[registrations_len_];
     registrations_len_ += 1;
 
     *new_registration = *registration;
@@ -118,8 +116,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_ABS, Register_ABS(), ParseAbs);
   }
 
-  TfLiteStatus AddAdd(
-      const TfLiteRegistration_V1& registration = Register_ADD()) {
+  TfLiteStatus AddAdd(const TFLMRegistration& registration = Register_ADD()) {
     return AddBuiltin(BuiltinOperator_ADD, registration, ParseAdd);
   }
 
@@ -142,10 +139,15 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddAveragePool2D(
-      const TfLiteRegistration_V1& registration = Register_AVERAGE_POOL_2D()) {
+      const TFLMRegistration& registration = Register_AVERAGE_POOL_2D()) {
     return AddBuiltin(BuiltinOperator_AVERAGE_POOL_2D, registration, ParsePool);
   }
 
+  TfLiteStatus AddBatchMatMul() {
+    return AddBuiltin(BuiltinOperator_BATCH_MATMUL,
+                      tflite::Register_BATCH_MATMUL(), ParseBatchMatMul);
+  }
+
   TfLiteStatus AddBatchToSpaceNd() {
     return AddBuiltin(BuiltinOperator_BATCH_TO_SPACE_ND,
                       Register_BATCH_TO_SPACE_ND(), ParseBatchToSpaceNd);
@@ -184,7 +186,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddConv2D(
-      const TfLiteRegistration_V1& registration = Register_CONV_2D()) {
+      const TFLMRegistration& registration = Register_CONV_2D()) {
     return AddBuiltin(BuiltinOperator_CONV_2D, registration, ParseConv2D);
   }
 
@@ -197,13 +199,18 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseCumsum);
   }
 
+  TfLiteStatus AddDelay() {
+    // TODO(b/286250473): change back name to "Delay" and remove namespace
+    return AddCustom("SignalDelay", tflite::tflm_signal::Register_DELAY());
+  }
+
   TfLiteStatus AddDepthToSpace() {
     return AddBuiltin(BuiltinOperator_DEPTH_TO_SPACE,
                       tflite::Register_DEPTH_TO_SPACE(), ParseDepthToSpace);
   }
 
-  TfLiteStatus AddDepthwiseConv2D(const TfLiteRegistration_V1& registration =
-                                      Register_DEPTHWISE_CONV_2D()) {
+  TfLiteStatus AddDepthwiseConv2D(
+      const TFLMRegistration& registration = Register_DEPTHWISE_CONV_2D()) {
     return AddBuiltin(BuiltinOperator_DEPTHWISE_CONV_2D, registration,
                       ParseDepthwiseConv2D);
   }
@@ -222,6 +229,16 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_DIV, tflite::Register_DIV(), ParseDiv);
   }
 
+  TfLiteStatus AddEmbeddingLookup() {
+    return AddBuiltin(BuiltinOperator_EMBEDDING_LOOKUP,
+                      Register_EMBEDDING_LOOKUP(), ParseEmbeddingLookup);
+  }
+
+  TfLiteStatus AddEnergy() {
+    // TODO(b/286250473): change back name to "Energy" and remove namespace
+    return AddCustom("SignalEnergy", tflite::tflm_signal::Register_ENERGY());
+  }
+
   TfLiteStatus AddElu() {
     return AddBuiltin(BuiltinOperator_ELU, tflite::Register_ELU(), ParseElu);
   }
@@ -231,7 +248,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddEthosU() {
-    TfLiteRegistration_V1* registration = tflite::Register_ETHOSU();
+    TFLMRegistration* registration = tflite::Register_ETHOSU();
     if (registration) {
       return AddCustom(tflite::GetString_ETHOSU(), registration);
     }
@@ -247,10 +264,41 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseExpandDims);
   }
 
+  TfLiteStatus AddFftAutoScale() {
+    // TODO(b/286250473): change back name and remove namespace
+    return AddCustom("SignalFftAutoScale",
+                     tflite::tflm_signal::Register_FFT_AUTO_SCALE());
+  }
+
   TfLiteStatus AddFill() {
     return AddBuiltin(BuiltinOperator_FILL, tflite::Register_FILL(), ParseFill);
   }
 
+  TfLiteStatus AddFilterBank() {
+    // TODO(b/286250473): change back name to "FilterBank" and remove namespace
+    return AddCustom("SignalFilterBank",
+                     tflite::tflm_signal::Register_FILTER_BANK());
+  }
+  TfLiteStatus AddFilterBankLog() {
+    // TODO(b/286250473): change back name to "FilterBankLog" and remove
+    // namespace
+    return AddCustom("SignalFilterBankLog",
+                     tflite::tflm_signal::Register_FILTER_BANK_LOG());
+  }
+  TfLiteStatus AddFilterBankSquareRoot() {
+    // TODO(b/286250473): change back name to "FilterBankSquareRoot" and remove
+    // namespace
+    return AddCustom("SignalFilterBankSquareRoot",
+                     tflite::tflm_signal::Register_FILTER_BANK_SQUARE_ROOT());
+  }
+  TfLiteStatus AddFilterBankSpectralSubtraction() {
+    // TODO(b/286250473): change back name to "FilterBankSpectralSubtraction"
+    // and remove namespace
+    return AddCustom(
+        "SignalFilterBankSpectralSubtraction",
+        tflite::tflm_signal::Register_FILTER_BANK_SPECTRAL_SUBTRACTION());
+  }
+
   TfLiteStatus AddFloor() {
     return AddBuiltin(BuiltinOperator_FLOOR, Register_FLOOR(), ParseFloor);
   }
@@ -265,8 +313,13 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseFloorMod);
   }
 
+  TfLiteStatus AddFramer() {
+    // TODO(b/286250473): change back name to "Framer" and remove namespace
+    return AddCustom("SignalFramer", tflite::tflm_signal::Register_FRAMER());
+  }
+
   TfLiteStatus AddFullyConnected(
-      const TfLiteRegistration_V1& registration = Register_FULLY_CONNECTED()) {
+      const TFLMRegistration& registration = Register_FULLY_CONNECTED()) {
     return AddBuiltin(BuiltinOperator_FULLY_CONNECTED, registration,
                       ParseFullyConnected);
   }
@@ -300,6 +353,12 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_IF, tflite::Register_IF(), ParseIf);
   }
 
+  TfLiteStatus AddIrfft(const TFLMRegistration* registration =
+                            tflite::tflm_signal::Register_IRFFT()) {
+    // TODO(b/286250473): change back name and remove namespace
+    return AddCustom("SignalIrfft", registration);
+  }
+
   TfLiteStatus AddL2Normalization() {
     return AddBuiltin(BuiltinOperator_L2_NORMALIZATION,
                       Register_L2_NORMALIZATION(), ParseL2Normalization);
@@ -359,7 +418,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddMaxPool2D(
-      const TfLiteRegistration_V1& registration = Register_MAX_POOL_2D()) {
+      const TFLMRegistration& registration = Register_MAX_POOL_2D()) {
     return AddBuiltin(BuiltinOperator_MAX_POOL_2D, registration, ParsePool);
   }
 
@@ -377,8 +436,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseMinimum);
   }
 
-  TfLiteStatus AddMul(
-      const TfLiteRegistration_V1& registration = Register_MUL()) {
+  TfLiteStatus AddMul(const TFLMRegistration& registration = Register_MUL()) {
     return AddBuiltin(BuiltinOperator_MUL, registration, ParseMul);
   }
 
@@ -391,12 +449,17 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseNotEqual);
   }
 
+  TfLiteStatus AddOverlapAdd() {
+    // TODO(b/286250473): change back name to "OverlapAdd" and remove namespace
+    return AddCustom("SignalOverlapAdd",
+                     tflite::tflm_signal::Register_OVERLAP_ADD());
+  }
+
   TfLiteStatus AddPack() {
     return AddBuiltin(BuiltinOperator_PACK, Register_PACK(), ParsePack);
   }
 
-  TfLiteStatus AddPad(
-      const TfLiteRegistration_V1& registration = Register_PAD()) {
+  TfLiteStatus AddPad(const TFLMRegistration& registration = Register_PAD()) {
     return AddBuiltin(BuiltinOperator_PAD, registration, ParsePad);
   }
 
@@ -404,6 +467,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_PADV2, Register_PADV2(), ParsePadV2);
   }
 
+  TfLiteStatus AddPCAN() {
+    // TODO(b/286250473): change back name to "PCAN" and remove namespace
+    return AddCustom("SignalPCAN", tflite::tflm_signal::Register_PCAN());
+  }
+
   TfLiteStatus AddPrelu() {
     return AddBuiltin(BuiltinOperator_PRELU, tflite::Register_PRELU(),
                       ParsePrelu);
@@ -434,8 +502,8 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddReshape() {
-    return AddBuiltin(BuiltinOperator_RESHAPE,
-                      tflite::ops::micro::Register_RESHAPE(), ParseReshape);
+    return AddBuiltin(BuiltinOperator_RESHAPE, Register_RESHAPE(),
+                      ParseReshape);
   }
 
   TfLiteStatus AddResizeBilinear() {
@@ -449,9 +517,14 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseResizeNearestNeighbor);
   }
 
+  TfLiteStatus AddRfft(const TFLMRegistration* registration =
+                           tflite::tflm_signal::Register_RFFT()) {
+    // TODO(b/286250473): change back name and remove namespace
+    return AddCustom("SignalRfft", registration);
+  }
+
   TfLiteStatus AddRound() {
-    return AddBuiltin(BuiltinOperator_ROUND,
-                      tflite::ops::micro::Register_ROUND(), ParseRound);
+    return AddBuiltin(BuiltinOperator_ROUND, Register_ROUND(), ParseRound);
   }
 
   TfLiteStatus AddRsqrt() {
@@ -476,7 +549,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddSoftmax(
-      const TfLiteRegistration_V1& registration = Register_SOFTMAX()) {
+      const TFLMRegistration& registration = Register_SOFTMAX()) {
     return AddBuiltin(BuiltinOperator_SOFTMAX, registration, ParseSoftmax);
   }
 
@@ -522,6 +595,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
                       ParseStridedSlice);
   }
 
+  TfLiteStatus AddStacker() {
+    // TODO(b/286250473): change back name to "Stacker" and remove namespace
+    return AddCustom("SignalStacker", tflite::tflm_signal::Register_STACKER());
+  }
+
   TfLiteStatus AddSub() {
     return AddBuiltin(BuiltinOperator_SUB, tflite::Register_SUB(), ParseSub);
   }
@@ -530,8 +608,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_SUM, Register_SUM(), ParseReducer);
   }
 
-  TfLiteStatus AddSvdf(
-      const TfLiteRegistration_V1& registration = Register_SVDF()) {
+  TfLiteStatus AddSvdf(const TFLMRegistration& registration = Register_SVDF()) {
     return AddBuiltin(BuiltinOperator_SVDF, registration, ParseSvdf);
   }
 
@@ -554,7 +631,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddUnidirectionalSequenceLSTM(
-      const TfLiteRegistration_V1& registration =
+      const TFLMRegistration& registration =
           Register_UNIDIRECTIONAL_SEQUENCE_LSTM()) {
     return AddBuiltin(BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
                       registration, ParseUnidirectionalSequenceLSTM);
@@ -569,6 +646,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return AddBuiltin(BuiltinOperator_WHILE, Register_WHILE(), ParseWhile);
   }
 
+  TfLiteStatus AddWindow() {
+    // TODO(b/286250473): change back name to "Window" and remove namespace
+    return AddCustom("SignalWindow", tflite::tflm_signal::Register_WINDOW());
+  }
+
   TfLiteStatus AddZerosLike() {
     return AddBuiltin(BuiltinOperator_ZEROS_LIKE, Register_ZEROS_LIKE(),
                       ParseZerosLike);
@@ -578,7 +660,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
  private:
   TfLiteStatus AddBuiltin(tflite::BuiltinOperator op,
-                          const TfLiteRegistration_V1& registration,
+                          const TFLMRegistration& registration,
                           TfLiteBridgeBuiltinParseFunction parser) {
     if (op == BuiltinOperator_CUSTOM) {
       MicroPrintf("Invalid parameter BuiltinOperator_CUSTOM to the ");
@@ -611,7 +693,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
     return kTfLiteOk;
   }
 
-  TfLiteRegistration_V1 registrations_[tOpCount];
+  TFLMRegistration registrations_[tOpCount];
   unsigned int registrations_len_ = 0;
 
   // Arrays (and counter) to store the builtin codes and their corresponding

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

@@ -16,6 +16,7 @@ limitations under the License.
 #define TENSORFLOW_LITE_MICRO_MICRO_OP_RESOLVER_H_
 
 #include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_common.h"
 #include "tensorflow/lite/micro/tflite_bridge/flatbuffer_conversions_bridge.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
@@ -35,11 +36,11 @@ class MicroOpResolver {
   // Returns the Op registration struct corresponding to the enum code from the
   // flatbuffer schema. Returns nullptr if the op is not found or if op ==
   // BuiltinOperator_CUSTOM.
-  virtual const TfLiteRegistration_V1* FindOp(BuiltinOperator op) const = 0;
+  virtual const TFLMRegistration* FindOp(BuiltinOperator op) const = 0;
 
   // Returns the Op registration struct corresponding to the custom operator by
   // name.
-  virtual const TfLiteRegistration_V1* FindOp(const char* op) const = 0;
+  virtual const TFLMRegistration* FindOp(const char* op) const = 0;
 
   // Returns the operator specific parsing function for the OpData for a
   // BuiltinOperator (if registered), else nullptr.
@@ -52,9 +53,9 @@ class MicroOpResolver {
 // Handles the logic for converting between an OperatorCode structure extracted
 // from a flatbuffer and information about a registered operator
 // implementation.
-TfLiteStatus GetRegistrationFromOpCode(
-    const OperatorCode* opcode, const MicroOpResolver& op_resolver,
-    const TfLiteRegistration_V1** registration);
+TfLiteStatus GetRegistrationFromOpCode(const OperatorCode* opcode,
+                                       const MicroOpResolver& op_resolver,
+                                       const TFLMRegistration** registration);
 
 }  // namespace tflite
 

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

@@ -87,7 +87,7 @@ class MicroProfiler : public MicroProfilerInterface {
 
   int FindExistingOrNextPosition(const char* tag_name);
 
-  TF_LITE_REMOVE_VIRTUAL_DELETE;
+  TF_LITE_REMOVE_VIRTUAL_DELETE
 };
 
 #if defined(TF_LITE_STRIP_ERROR_STRINGS)

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

@@ -30,13 +30,13 @@ class MockMicroGraph : public MicroGraph {
  public:
   explicit MockMicroGraph(SingleArenaBufferAllocator* allocator);
   TfLiteStatus InvokeSubgraph(int subgraph_idx) override;
-  TfLiteStatus ResetVariableTensors() override;
   size_t NumSubgraphInputs(int subgraph_idx) override;
   TfLiteEvalTensor* GetSubgraphInput(int subgraph_idx, int tensor_idx) override;
   size_t NumSubgraphOutputs(int subgraph_idx) override;
   TfLiteEvalTensor* GetSubgraphOutput(int subgraph_idx,
                                       int tensor_idx) override;
   int NumSubgraphs() override;
+  MicroResourceVariables* GetResourceVariables() override;
   int get_init_count() const { return init_count_; }
   int get_prepare_count() const { return prepare_count_; }
   int get_free_count() const { return free_count_; }