chore: import upstream snapshot with attribution

tensorflow/lite/experimental/ml_adjacent/data/BUILD

@@ -0,0 +1,27 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "owning_vector_ref",
+    srcs = ["owning_vector_ref.cc"],
+    hdrs = [
+        "owning_vector_ref.h",
+    ],
+    deps = ["//tensorflow/lite/experimental/ml_adjacent:lib"],
+)
+
+cc_test(
+    name = "owning_vector_ref_test",
+    srcs = ["owning_vector_ref_test.cc"],
+    deps = [
+        ":owning_vector_ref",
+        "//tensorflow/lite/experimental/ml_adjacent:lib",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

tensorflow/lite/experimental/ml_adjacent/data/owning_vector_ref.cc

@@ -0,0 +1,54 @@
+/* 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.
+==============================================================================*/
+#include "tensorflow/lite/experimental/ml_adjacent/data/owning_vector_ref.h"
+
+#include <cstddef>
+
+#include "tensorflow/lite/experimental/ml_adjacent/lib.h"
+
+namespace ml_adj {
+namespace data {
+
+void OwningVectorRef::Resize(dims_t&& dims) {
+  dims_ = dims;
+
+  num_elements_ = 0;
+  // TODO(b/292143456) Add a helper for this.
+  for (dim_t d : dims_) {
+    if (d <= 0) {
+      break;
+    }
+    if (num_elements_ == 0) {
+      num_elements_ = d;
+    } else {
+      num_elements_ *= d;
+    }
+  }
+
+  raw_data_buffer_.resize(num_elements_ * TypeWidth(Type()));
+}
+
+const void* OwningVectorRef::Data() const { return raw_data_buffer_.data(); }
+
+void* OwningVectorRef::Data() { return raw_data_buffer_.data(); }
+
+ind_t OwningVectorRef::NumElements() const { return num_elements_; }
+
+size_t OwningVectorRef::Bytes() const {
+  return NumElements() * TypeWidth(Type());
+}
+
+}  // namespace data
+}  // namespace ml_adj

tensorflow/lite/experimental/ml_adjacent/data/owning_vector_ref.h

@@ -0,0 +1,58 @@
+/* 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_EXPERIMENTAL_ML_ADJACENT_DATA_OWNING_VECTOR_REF_H_
+#define TENSORFLOW_LITE_EXPERIMENTAL_ML_ADJACENT_DATA_OWNING_VECTOR_REF_H_
+#include <vector>
+
+#include "tensorflow/lite/experimental/ml_adjacent/lib.h"
+
+namespace ml_adj {
+namespace data {
+
+// A MutableDataRef implemenation that manages its buffer through underlying
+// vector which it owns.
+class OwningVectorRef : public MutableDataRef {
+ public:
+  explicit OwningVectorRef(etype_t type) : MutableDataRef(type) {}
+
+  OwningVectorRef(const OwningVectorRef&) = delete;
+  OwningVectorRef(OwningVectorRef&&) = delete;
+  OwningVectorRef& operator=(const OwningVectorRef&) = delete;
+  OwningVectorRef& operator=(OwningVectorRef&&) = delete;
+
+  // Resizes the underlying vector to prod(dims) * type width.
+  void Resize(dims_t&& dims) override;
+
+  // Gets read-only pointer to vector's buffer.
+  const void* Data() const override;
+
+  // Gets a write-read pointer to vector's buffer.
+  void* Data() override;
+
+  ind_t NumElements() const override;
+
+  size_t Bytes() const override;
+
+  ~OwningVectorRef() override = default;
+
+ private:
+  std::vector<char> raw_data_buffer_;
+  ind_t num_elements_ = 0;
+};
+
+}  // namespace data
+}  // namespace ml_adj
+
+#endif  // TENSORFLOW_LITE_EXPERIMENTAL_ML_ADJACENT_DATA_OWNING_VECTOR_REF_H_

tensorflow/lite/experimental/ml_adjacent/data/owning_vector_ref_test.cc

@@ -0,0 +1,89 @@
+/* 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.
+==============================================================================*/
+#include "tensorflow/lite/experimental/ml_adjacent/data/owning_vector_ref.h"
+
+#include <algorithm>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "tensorflow/lite/experimental/ml_adjacent/lib.h"
+
+namespace ml_adj {
+namespace data {
+namespace {
+
+using ::testing::ElementsAreArray;
+using ::testing::IsEmpty;
+
+TEST(OwningVectorRefTest, ConstructFloat32) {
+  OwningVectorRef t(etype_t::f32);
+
+  EXPECT_EQ(t.Type(), etype_t::f32);
+  EXPECT_EQ(t.NumElements(), 0);
+  EXPECT_EQ(t.Bytes(), 0);
+  EXPECT_THAT(t.Dims(), IsEmpty());
+}
+
+TEST(OwningVectorRefTest, ResizeFromEmptyFloat32) {
+  OwningVectorRef t(etype_t::f32);
+  t.Resize({2, 2});
+
+  EXPECT_THAT(t.Dims(), ElementsAreArray<dim_t>({2, 2}));
+  EXPECT_EQ(t.NumElements(), 4);
+  ASSERT_EQ(t.Bytes(), 4 * sizeof(float));
+
+  // Check buffer is correct.
+  float* write_f_start = reinterpret_cast<float*>(t.Data());
+  float* write_f_end = write_f_start + t.NumElements();
+  std::fill(write_f_start, write_f_end, 0.5f);
+
+  const float* read_f_start = reinterpret_cast<const float*>(t.Data());
+  for (int i = 0; i < t.NumElements(); ++i) {
+    EXPECT_EQ(read_f_start[i], 0.5f);
+  }
+}
+
+TEST(OwningVectorRefTest, ResizeDownFloat32) {
+  OwningVectorRef t(etype_t::f32);
+  t.Resize({2, 2});
+
+  float* write_f_start = reinterpret_cast<float*>(t.Data());
+  float* write_f_end = write_f_start + t.NumElements();
+  std::fill(write_f_start, write_f_end, 0.5f);
+
+  t.Resize({3});
+  ASSERT_THAT(t.Dims(), ElementsAreArray<dim_t>({3}));
+  EXPECT_EQ(t.NumElements(), 3);
+  ASSERT_EQ(t.Bytes(), 3 * sizeof(float));
+
+  const float* read_f_start = reinterpret_cast<const float*>(t.Data());
+  for (int i = 0; i < t.NumElements(); ++i) {
+    EXPECT_EQ(read_f_start[i], 0.5f);
+  }
+}
+
+TEST(OwningVectorRefTest, IgnoresDimsForNumElementsAfterFirstNonPositive) {
+  OwningVectorRef t(etype_t::f32);
+  t.Resize({3, 0, 0, 2});
+
+  EXPECT_EQ(t.Type(), etype_t::f32);
+  EXPECT_EQ(t.NumElements(), 3);
+  EXPECT_EQ(t.Bytes(), 3 * sizeof(float));
+  EXPECT_THAT(t.Dims(), ElementsAreArray<dim_t>({3, 0, 0, 2}));
+}
+
+}  // namespace
+}  // namespace data
+}  // namespace ml_adj