Merge branch 'ci/sync_gh_tflite-lib' into 'master'

Update tflite-lib (synced from github) - 535770

See merge request app-frameworks/tflite-micro-esp-examples!97

Author: vikramdattu

components/tflite-lib/tensorflow/lite/core/api/op_resolver.h

@@ -28,6 +28,13 @@ namespace tflite {
 /// Abstract interface that returns TfLiteRegistrations given op codes or custom
 /// op names. This is the mechanism that ops being referenced in the flatbuffer
 /// model are mapped to executable function pointers (TfLiteRegistrations).
+///
+/// The lifetime of the TfLiteRegistration object whose address is
+/// returned by FindOp must exceed the lifetime of any InterpreterBuilder or
+/// Interpreter created with this OpResolver.
+/// Likewise the lifetime of the TfLiteRegistrationExternal object referenced
+/// from the TfLiteRegistration object, if any, must exceed the lifetime of
+/// any InterpreterBuilder or Interpreter created with this OpResolver.
 class OpResolver {
  public:
   /// Finds the op registration for a builtin operator by enum code.

components/tflite-lib/tensorflow/lite/core/c/common.cc

@@ -15,99 +15,139 @@ limitations under the License.
 
 #include "tensorflow/lite/core/c/common.h"
 
+#ifndef TF_LITE_STATIC_MEMORY
+#include <cstdlib>
+#endif  // TF_LITE_STATIC_MEMORY
+
+#include <cstring>
+#include <type_traits>
+#include <utility>
+
 #include "tensorflow/lite/core/c/c_api_types.h"
 #ifdef TF_LITE_TENSORFLOW_PROFILER
 #include "tensorflow/lite/tensorflow_profiler_logger.h"
 #endif
 
+namespace {
+
+template <class T>
+size_t TfLiteVarArrayGetSizeInBytes(const int size) {
+  constexpr size_t data_size = sizeof(std::declval<T>().data[0]);
+  size_t computed_size = sizeof(T) + data_size * size;
+#if defined(_MSC_VER)
+  // Context for why this is needed is in http://b/189926408#comment21
+  computed_size -= data_size;
+#endif
+  return computed_size;
+}
+
+template <class T, class U>
+int TfLiteVarArrayEqualsArray(const T* const a, const int b_size,
+                              const U* const b_data) {
+  static_assert(std::is_same<decltype(a->data[0]), const U&>::value,
+                "TfLiteVarArrayEqualsArray can only compare same type arrays");
+  if (a == nullptr) {
+    return b_size == 0;
+  }
+  if (a->size != b_size) {
+    return 0;
+  }
+  return !memcmp(a->data, b_data, a->size * sizeof(a->data[0]));
+}
+
+template <class T>
+int TfLiteVarArrayEqual(const T* const a, const T* const b) {
+  // This goes first because null arrays must compare equal.
+  if (a == b) {
+    return 1;
+  }
+  if (a == nullptr || b == nullptr) {
+    return 0;
+  }
+  return TfLiteVarArrayEqualsArray(a, b->size, b->data);
+}
+
 #ifndef TF_LITE_STATIC_MEMORY
-#include <stdlib.h>
-#include <string.h>
+
+template <class T>
+T* TfLiteVarArrayCreate(const int size) {
+  const size_t alloc_size = TfLiteVarArrayGetSizeInBytes<T>(size);
+  if (alloc_size <= 0) {
+    return nullptr;
+  }
+  T* ret = (T*)malloc(alloc_size);
+  if (!ret) {
+    return nullptr;
+  }
+  ret->size = size;
+  return ret;
+}
+
+template <class T>
+T* TfLiteVarArrayCopy(const T* const src) {
+  if (!src) {
+    return nullptr;
+  }
+  T* const ret = TfLiteVarArrayCreate<T>(src->size);
+  if (ret) {
+    memcpy(ret->data, src->data, src->size * sizeof(src->data[0]));
+  }
+  return ret;
+}
+
 #endif  // TF_LITE_STATIC_MEMORY
 
+template <class T>
+void TfLiteVarArrayFree(T* a) {
+  free(a);
+}
+
+}  // namespace
+
 extern "C" {
 
 size_t TfLiteIntArrayGetSizeInBytes(int size) {
-  static TfLiteIntArray dummy;
-
-  size_t computed_size = sizeof(dummy) + sizeof(dummy.data[0]) * size;
-#if defined(_MSC_VER)
-  // Context for why this is needed is in http://b/189926408#comment21
-  computed_size -= sizeof(dummy.data[0]);
-#endif
-  return computed_size;
+  return TfLiteVarArrayGetSizeInBytes<TfLiteIntArray>(size);
 }
 
 int TfLiteIntArrayEqual(const TfLiteIntArray* a, const TfLiteIntArray* b) {
-  if (a == b) return 1;
-  if (a == nullptr || b == nullptr) return 0;
-  return TfLiteIntArrayEqualsArray(a, b->size, b->data);
+  return TfLiteVarArrayEqual(a, b);
 }
 
 int TfLiteIntArrayEqualsArray(const TfLiteIntArray* a, int b_size,
                               const int b_data[]) {
-  if (a == nullptr) return (b_size == 0);
-  if (a->size != b_size) return 0;
-  int i = 0;
-  for (; i < a->size; i++)
-    if (a->data[i] != b_data[i]) return 0;
-  return 1;
+  return TfLiteVarArrayEqualsArray(a, b_size, b_data);
 }
 
 #ifndef TF_LITE_STATIC_MEMORY
 
 TfLiteIntArray* TfLiteIntArrayCreate(int size) {
-  size_t alloc_size = TfLiteIntArrayGetSizeInBytes(size);
-  if (alloc_size <= 0) return nullptr;
-  TfLiteIntArray* ret = (TfLiteIntArray*)malloc(alloc_size);
-  if (!ret) return ret;
-  ret->size = size;
-  return ret;
+  return TfLiteVarArrayCreate<TfLiteIntArray>(size);
 }
 
 TfLiteIntArray* TfLiteIntArrayCopy(const TfLiteIntArray* src) {
-  if (!src) return nullptr;
-  TfLiteIntArray* ret = TfLiteIntArrayCreate(src->size);
-  if (ret) {
-    memcpy(ret->data, src->data, src->size * sizeof(int));
-  }
-  return ret;
+  return TfLiteVarArrayCopy(src);
 }
 
-void TfLiteIntArrayFree(TfLiteIntArray* a) { free(a); }
+void TfLiteIntArrayFree(TfLiteIntArray* a) { TfLiteVarArrayFree(a); }
 
 #endif  // TF_LITE_STATIC_MEMORY
 
 int TfLiteFloatArrayGetSizeInBytes(int size) {
-  static TfLiteFloatArray dummy;
-
-  int computed_size = sizeof(dummy) + sizeof(dummy.data[0]) * size;
-#if defined(_MSC_VER)
-  // Context for why this is needed is in http://b/189926408#comment21
-  computed_size -= sizeof(dummy.data[0]);
-#endif
-  return computed_size;
+  return TfLiteVarArrayGetSizeInBytes<TfLiteFloatArray>(size);
 }
 
 #ifndef TF_LITE_STATIC_MEMORY
 
 TfLiteFloatArray* TfLiteFloatArrayCreate(int size) {
-  TfLiteFloatArray* ret =
-      (TfLiteFloatArray*)malloc(TfLiteFloatArrayGetSizeInBytes(size));
-  ret->size = size;
-  return ret;
+  return TfLiteVarArrayCreate<TfLiteFloatArray>(size);
 }
 
 TfLiteFloatArray* TfLiteFloatArrayCopy(const TfLiteFloatArray* src) {
-  if (!src) return nullptr;
-  TfLiteFloatArray* ret = TfLiteFloatArrayCreate(src->size);
-  if (ret) {
-    memcpy(ret->data, src->data, src->size * sizeof(float));
-  }
-  return ret;
+  return TfLiteVarArrayCopy(src);
 }
 
-void TfLiteFloatArrayFree(TfLiteFloatArray* a) { free(a); }
+void TfLiteFloatArrayFree(TfLiteFloatArray* a) { TfLiteVarArrayFree(a); }
 
 void TfLiteTensorDataFree(TfLiteTensor* t) {
   if (t->allocation_type == kTfLiteVariantObject) {

components/tflite-lib/tensorflow/lite/kernels/kernel_util.h

@@ -204,22 +204,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.