Fix non-kernel refs to the deprecated Tensor::data_ptr()

Summary: Plain `Tensor::data_ptr()` is deprecated, so we should stop using it internally.

Reviewed By: larryliu0820

Differential Revision: D48076575

fbshipit-source-id: 0f2fda783a86f1e673494700a79fb61faef229f7

Author: dbort

backends/xnnpack/runtime/XNNExecutor.cpp

@@ -56,12 +56,12 @@ Error XNNExecutor::set_external_input(uint32_t id, Tensor* input) {
         e == Error::Ok, Internal, "QuantizePerTensor() failed");
     externals_.emplace_back(xnn_external_value{
         id,
-        qinput.data_ptr(),
+        qinput.mutable_data_ptr(),
         {static_cast<float>(input_qparam.scale),
          static_cast<int8_t>(input_qparam.zero_point)},
         batch_size});
   } else {
-    externals_.emplace_back(xnn_external_value{id, input->data_ptr()});
+    externals_.emplace_back(xnn_external_value{id, input->mutable_data_ptr()});
   }
   return Error::Ok;
 }

backends/xnnpack/runtime/XNNExecutor.h

@@ -111,8 +111,8 @@ class XNNExecutor {
         outputs.size());
 
     for (int i = 0; i < outputs.size(); i++) {
-      externals_.emplace_back(
-          xnn_external_value{output_ids_[i], outputs[i]->data_ptr<float>()});
+      externals_.emplace_back(xnn_external_value{
+          output_ids_[i], outputs[i]->mutable_data_ptr<float>()});
     }
 
     return Error::Ok;

extension/aten_util/aten_bridge.cpp

@@ -135,15 +135,15 @@ void alias_etensor_to_attensor(
   // then in the next call copying will not be the correct behavior.
   ET_CHECK_MSG(aten_tensor.is_contiguous(), "Input tensor must be contiguous");
   check_tensor_meta(aten_tensor, mutable_et);
-  mutable_et.unsafeGetTensorImpl()->set_data(aten_tensor.data_ptr());
+  mutable_et.unsafeGetTensorImpl()->set_data(aten_tensor.mutable_data_ptr());
 }
 
 at::Tensor alias_attensor_to_etensor(const torch::executor::Tensor& etensor) {
   c10::ScalarType dtype = execuTorchtoTorchScalarType(etensor.scalar_type());
   std::vector<int64_t> at_tensor_sizes(
       etensor.sizes().begin(), etensor.sizes().end());
   at::Tensor t = at::from_blob(
-      etensor.data_ptr(), at_tensor_sizes, at::TensorOptions(dtype));
+      etensor.mutable_data_ptr(), at_tensor_sizes, at::TensorOptions(dtype));
   check_tensor_meta(t, etensor);
   return t;
 }
@@ -164,7 +164,7 @@ std::unique_ptr<torch::executor::TensorImpl> eTensorFromAtTensor(
       torchToExecuTorchScalarType(options.dtype());
 
   return std::make_unique<torch::executor::TensorImpl>(
-      edtype, sizes32.size(), sizes32.data(), tensor.data_ptr());
+      edtype, sizes32.size(), sizes32.data(), tensor.mutable_data_ptr());
 }
 
 at::Tensor atTensorFromETensor(

extension/aten_util/test/aten_bridge_test.cpp

@@ -47,7 +47,7 @@ TEST(ATenBridgeTest, AliasETensorToATenTensor) {
       strides.data());
   torch::executor::Tensor etensor(&tensor_impl);
   alias_etensor_to_attensor(at_tensor, etensor);
-  EXPECT_EQ(at_tensor.data_ptr(), etensor.data_ptr());
+  EXPECT_EQ(at_tensor.const_data_ptr(), etensor.const_data_ptr());
 }
 
 TEST(ATenBridgeTest, AliasETensorToATenTensorFail) {
@@ -99,8 +99,8 @@ TEST(ATenBridgeTest, AliasETensorToATenTensorNonContiguous) {
       strides.data());
   torch::executor::Tensor etensor(&tensor_impl);
   alias_etensor_to_attensor(sliced_tensor_contig, etensor);
-  EXPECT_EQ(sliced_tensor_contig.data_ptr(), etensor.data_ptr());
-  EXPECT_NE(sliced_tensor.data_ptr(), etensor.data_ptr());
+  EXPECT_EQ(sliced_tensor_contig.const_data_ptr(), etensor.const_data_ptr());
+  EXPECT_NE(sliced_tensor.const_data_ptr(), etensor.const_data_ptr());
 }
 
 TEST(ATenBridgeTest, AliasETensorToATenTensorNonContiguousFail) {
@@ -144,5 +144,5 @@ TEST(ATenBridgeTest, AliasATTensorToETensor) {
       strides.data());
   torch::executor::Tensor etensor(&tensor_impl);
   auto aliased_at_tensor = alias_attensor_to_etensor(etensor);
-  EXPECT_EQ(aliased_at_tensor.data_ptr(), etensor_data.data());
+  EXPECT_EQ(aliased_at_tensor.const_data_ptr(), etensor_data.data());
 }

runtime/core/exec_aten/testing_util/tensor_util.cpp

@@ -86,8 +86,8 @@ bool tensors_are_close(
   // Since the two tensors have same shape and strides, any two elements that
   // share same index from underlying data perspective will also share same
   // index from tensor perspective, whatever the size and strides really are.
-  // e.g. if a[i_1, i_2, ... i_n] = a.data_ptr()[m], we can assert
-  // b[i_1, i_2, ... i_n] = b.data_ptr()[m])
+  // e.g. if a[i_1, i_2, ... i_n] = a.const_data_ptr()[m], we can assert
+  // b[i_1, i_2, ... i_n] = b.const_data_ptr()[m])
   // So we can just compare the two underlying data sequentially to figure out
   // if the two tensors are same.
 
@@ -112,7 +112,7 @@ bool tensors_are_close(
         atol);
   } else {
     // Non-floating-point types can be compared bitwise.
-    return memcmp(a.data_ptr(), b.data_ptr(), a.nbytes()) == 0;
+    return memcmp(a.const_data_ptr(), b.const_data_ptr(), a.nbytes()) == 0;
   }
 }
 
@@ -152,7 +152,7 @@ bool tensor_data_is_close(
         atol);
   } else {
     // Non-floating-point types can be compared bitwise.
-    return memcmp(a.data_ptr(), b.data_ptr(), a.nbytes()) == 0;
+    return memcmp(a.const_data_ptr(), b.const_data_ptr(), a.nbytes()) == 0;
   }
 }
 

runtime/core/exec_aten/util/scalar_type_util.h

@@ -732,14 +732,15 @@ inline size_t sizeof_scalar_type(exec_aten::ScalarType type) {
 // An example usage is:
 //
 // ET_SWITCH_REAL_TYPES(input.scalar_type(), "example", CTYPE, [&]() {
-//   output.const_data_ptr<CTYPE>[0] = input.data_ptr<CTYPE>[0];
+//   output.mutable_data_ptr<CTYPE>[0] = input.const_data_ptr<CTYPE>[0];
 // });
 //
 // Note that these can be nested as well:
 //
 // ET_SWITCH_REAL_TYPES(input.scalar_type(), "example", CTYPE_IN, [&]() {
 //   ET_SWITCH_REAL_TYPES(output.scalar_type(), "example", CTYPE_OUT, [&]() {
-//     output.const_data_ptr<CTYPE_OUT>[0] = input.data_ptr<CTYPE_IN>[0];
+//     output.mutable_data_ptr<CTYPE_OUT>[0] =
+//         input.const_data_ptr<CTYPE_IN>[0];
 //   });
 // });
 //

runtime/core/exec_aten/util/tensor_util_aten.cpp

@@ -51,35 +51,35 @@ Error share_tensor_data(const at::Tensor& t_dst, const at::Tensor& t_src) {
       InvalidArgument,
       "Source tensor should have data_ptr not being nullptr.");
   // Assign the dataptr as the input tensor dataptr
-  storage->set_data_ptr(at::DataPtr(t_src.data_ptr(), DeviceType::CPU));
+  storage->set_data_ptr(at::DataPtr(t_src.mutable_data_ptr(), DeviceType::CPU));
   storage->set_nbytes(t_src.nbytes());
 
   return Error::Ok;
 }
 
 Error copy_tensor_data(const at::Tensor& t_dst, const at::Tensor& t_src) {
-  at::StorageImpl* storage =
-      t_dst.unsafeGetTensorImpl()->unsafe_storage().unsafeGetStorageImpl();
-  void* data_ptr = storage->data_ptr().get();
+  void* dst_data_ptr = t_dst.mutable_data_ptr();
 
   // Currently even 0 sized tensors receive a dataptr in pre_allocated
   // memory planning so we can do this check.
   // TODO(jakeszwe, shunting, gasoonjia): this should be clear in design if
   // other people make their own memory plans
   ET_CHECK_OR_RETURN_ERROR(
-      data_ptr != nullptr,
+      dst_data_ptr != nullptr,
       InvalidArgument,
-      "Source tensor should have data_ptr not being nullptr.");
-  // memcpy the data of given tensor list to preallocated memory of input
-  // inputs with a size 0 dimension can be nullptr
-  if (t_src.data_ptr() != nullptr) {
+      "Destination tensor data pointer must not be null.");
+
+  // Sources with a size 0 dimension can be nullptr
+  if (t_src.const_data_ptr() != nullptr) {
     ET_CHECK_OR_RETURN_ERROR(
         t_dst.nbytes() == t_src.nbytes(),
         InvalidArgument,
         "t_dst.nbytes() %lu != t_src.nbytes(). %lu",
         t_dst.nbytes(),
         t_src.nbytes());
-    std::memcpy(data_ptr, t_src.data_ptr(), t_src.nbytes());
+    // Copy the source data to the preallocated memory of the destination, which
+    // must be the same size as the source.
+    std::memcpy(dst_data_ptr, t_src.const_data_ptr(), t_src.nbytes());
   }
 
   return Error::Ok;

runtime/executor/method.cpp

@@ -624,7 +624,8 @@ Error Method::init(executorch_flatbuffer::ExecutionPlan* s_plan) {
   // Get pre_allocation info for input tensors
   for (int i = 0; i < inputs_size(); i++) {
     if (get_input(i).isTensor()) {
-      pre_allocated_input_ = get_input(i).toTensor().data_ptr() != nullptr;
+      pre_allocated_input_ =
+          get_input(i).toTensor().const_data_ptr() != nullptr;
       break;
     }
   }

util/bundled_program_verification.cpp

@@ -46,7 +46,7 @@ at::Tensor tensor_like(executorch_flatbuffer::BundledTensor* bundled_tensor) {
       {ret_t_sizes, bundled_tensor->sizes()->size()},
       at::dtype(static_cast<ScalarType>(bundled_tensor->scalar_type())));
   memcpy(
-      ret_tensor.data_ptr(),
+      ret_tensor.mutable_data_ptr(),
       static_cast<const void*>(bundled_tensor->data()->Data()),
       ret_tensor.nbytes());
   return ret_tensor;

util/util.h

@@ -75,8 +75,7 @@ inline exec_aten::ArrayRef<void*> PrepareInputTensors(const Method& method) {
     const auto& t = method.get_input(i).toTensor();
     at::StorageImpl* storage =
         t.unsafeGetTensorImpl()->unsafe_storage().unsafeGetStorageImpl();
-    auto& data_ptr = storage->data_ptr();
-    if (data_ptr.get() == nullptr) {
+    if (storage->data_ptr().get() == nullptr) {
       ET_LOG(Info, "input not initialized.");
       inputs[num_allocated++] = malloc(t.nbytes());
       storage->set_data_ptr(at::DataPtr(
@@ -97,7 +96,7 @@ inline exec_aten::ArrayRef<void*> PrepareInputTensors(const Method& method) {
       continue;
     }
     const auto& t = method.get_input(i).toTensor();
-    if (t.data_ptr() == nullptr) {
+    if (t.const_data_ptr() == nullptr) {
       ET_LOG(Info, "input not initialized.");
       inputs[num_allocated++] = malloc(t.nbytes());
       t.set_data(inputs[num_allocated - 1]);