Remove inline Tensor decl from tensor_util.h (#4577)

Summary:
Pull Request resolved: #4577

Header files must not use `using` declarations to create aliases, especially just to reduce typing. https://google.github.io/styleguide/cppguide.html#Aliases

In this case it added extra confusion because it made `exec_aten::Tensor` available as `torch::executor::Tensor`; but, `torch::executor::Tensor` is the "lean" implementation of tensor, and `exec_aten::Tensor` is an alias for `torch::executor::Tensor` in lean mode, but not in aten mode.

Differential Revision: D60869599

fbshipit-source-id: aaa8df51e3eac4ee33d8b6c863d08e7cf6a3eeb8

Author: dbort

examples/models/llama2/runner/runner.cpp

@@ -130,7 +130,7 @@ int32_t Runner::logitsToToken(const exec_aten::Tensor& logits_tensor) {
   }
 }
 
-Result<torch::executor::Tensor> Runner::prefill(
+Result<exec_aten::Tensor> Runner::prefill(
     const std::vector<uint64_t>& tokens,
     ManagedTensor& managed_tokens,
     ManagedTensor& managed_start_pos,
@@ -202,7 +202,7 @@ Result<torch::executor::Tensor> Runner::prefill(
     auto logits_tensor = managed_tokens.get_aliasing_tensor();
     while (pos < num_tokens) {
       // Run the model
-      Result<torch::executor::Tensor> logits_res = run_model_step(
+      Result<exec_aten::Tensor> logits_res = run_model_step(
           cur_token, managed_tokens, managed_start_pos, num_tokens);
 
       ET_CHECK_OK_OR_RETURN_ERROR(logits_res.error());
@@ -243,7 +243,7 @@ Result<torch::executor::Tensor> Runner::prefill(
 
 // Given an input token. Set up the inputs for the model and execute a single
 // step. Returning the logits tensor.
-Result<torch::executor::Tensor> Runner::run_model_step(
+Result<exec_aten::Tensor> Runner::run_model_step(
     int64_t input_token,
     ManagedTensor& managed_tokens,
     ManagedTensor& managed_start_pos,
@@ -411,7 +411,7 @@ Error Runner::generate(
   // Generate our tokens
   while (pos < seq_len - 1) {
     // Run the model
-    Result<torch::executor::Tensor> logits_res =
+    Result<exec_aten::Tensor> logits_res =
         run_model_step(cur_token, tokens_managed, start_pos_managed, seq_len);
 
     ET_CHECK_OK_OR_RETURN_ERROR(logits_res.error());

examples/models/llama2/runner/runner.h

@@ -45,12 +45,12 @@ class Runner {
 
  private:
   int32_t logitsToToken(const exec_aten::Tensor& logits_tensor);
-  Result<torch::executor::Tensor> prefill(
+  Result<exec_aten::Tensor> prefill(
       const std::vector<uint64_t>& tokens,
       ManagedTensor& managed_tokens,
       ManagedTensor& managed_start_pos,
       std::function<void(const std::string&)> token_callback);
-  Result<torch::executor::Tensor> run_model_step(
+  Result<exec_aten::Tensor> run_model_step(
       int64_t input_token,
       ManagedTensor& tokens,
       ManagedTensor& start_pos,

runtime/core/exec_aten/util/tensor_util.h

@@ -400,10 +400,6 @@
 namespace torch {
 namespace executor {
 
-using Tensor = exec_aten::Tensor;
-using Scalar = exec_aten::Scalar;
-using ScalarType = exec_aten::ScalarType;
-
 //
 // Utility functions for checking tensor attributes
 //
@@ -432,7 +428,7 @@ inline bool dim_is_valid(int64_t dim, int64_t upper_bound) {
  * the zero dimensional tensors in some kernels, that treat them as 1D tensors
  * with a single element.
  */
-inline ssize_t nonzero_dim(const Tensor& tensor) {
+inline ssize_t nonzero_dim(const exec_aten::Tensor& tensor) {
   return tensor.dim() == 0 ? 1 : tensor.dim();
 }
 
@@ -442,7 +438,7 @@ inline ssize_t nonzero_dim(const Tensor& tensor) {
  * the zero dimensional tensors in some kernels, that treat them as 1D tensors
  * with a single element.
  */
-inline ssize_t nonempty_size(const Tensor& tensor, ssize_t dim) {
+inline ssize_t nonempty_size(const exec_aten::Tensor& tensor, ssize_t dim) {
   return tensor.dim() == 0 ? 1 : tensor.size(dim);
 }
 
@@ -861,7 +857,7 @@ inline bool tensor_is_scalar(exec_aten::Tensor t) {
 constexpr size_t kTensorDimensionLimit = 16;
 
 /// Returns the product of dim[0:dim), not including dim.
-inline size_t getLeadingDims(const Tensor& tensor, int64_t dim) {
+inline size_t getLeadingDims(const exec_aten::Tensor& tensor, int64_t dim) {
   ET_CHECK_MSG(
       dim >= 0 && dim <= tensor.dim(),
       "Ending dimension %" PRId64
@@ -876,7 +872,7 @@ inline size_t getLeadingDims(const Tensor& tensor, int64_t dim) {
 }
 
 /// Returns the product of dim[dim+1:].
-inline size_t getTrailingDims(const Tensor& tensor, int64_t dim) {
+inline size_t getTrailingDims(const exec_aten::Tensor& tensor, int64_t dim) {
   ET_CHECK_MSG(
       dim >= -1 && dim < tensor.dim(),
       "Starting dimension %" PRId64
@@ -901,7 +897,7 @@ inline size_t getTrailingDims(const Tensor& tensor, int64_t dim) {
  * the tensor.
  */
 inline size_t coordinateToIndex(
-    const Tensor& tensor,
+    const exec_aten::Tensor& tensor,
     const size_t* const coordinate) {
   size_t index = 0;
   for (int d = 0; d < tensor.dim(); ++d) {
@@ -921,8 +917,10 @@ inline size_t coordinateToIndex(
  * index. It is assumed that the array has kTensorDimensionLimit elements.
  * @returns void
  */
-inline void
-indexToCoordinate(const Tensor& tensor, size_t index, size_t* coordinate) {
+inline void indexToCoordinate(
+    const exec_aten::Tensor& tensor,
+    size_t index,
+    size_t* coordinate) {
   ET_CHECK(index < tensor.numel());
   for (auto i = 0; i < tensor.dim(); ++i) {
     auto dim = tensor.dim() - 1 - i;
@@ -947,12 +945,12 @@ template <
     typename std::enable_if<
         std::is_integral<INT_T>::value && !std::is_same<INT_T, bool>::value,
         bool>::type = true>
-bool extract_scalar_tensor(Tensor tensor, INT_T* out_val) {
+bool extract_scalar_tensor(exec_aten::Tensor tensor, INT_T* out_val) {
   if (tensor.numel() != 1) {
     return false;
   }
 #define CASE_INT_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                     \
-  case ScalarType::TENSOR_DTYPE: {                                     \
+  case exec_aten::ScalarType::TENSOR_DTYPE: {                          \
     const TENSOR_CTYPE val = tensor.const_data_ptr<TENSOR_CTYPE>()[0]; \
     if (val < std::numeric_limits<INT_T>::lowest() ||                  \
         val > std::numeric_limits<INT_T>::max()) {                     \
@@ -984,12 +982,12 @@ template <
     typename FLOAT_T,
     typename std::enable_if<std::is_floating_point<FLOAT_T>::value, bool>::
         type = true>
-bool extract_scalar_tensor(Tensor tensor, FLOAT_T* out_val) {
+bool extract_scalar_tensor(exec_aten::Tensor tensor, FLOAT_T* out_val) {
   if (tensor.numel() != 1) {
     return false;
   }
 #define CASE_REAL_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                    \
-  case ScalarType::TENSOR_DTYPE: {                                     \
+  case exec_aten::ScalarType::TENSOR_DTYPE: {                          \
     /* ET_FORALL_REAL_TYPES guarantees TENSOR_CTYPE is a real type. */ \
     double val =                                                       \
         static_cast<double>(tensor.const_data_ptr<TENSOR_CTYPE>()[0]); \
@@ -1022,7 +1020,7 @@ template <
     typename BOOL_T,
     typename std::enable_if<std::is_same<BOOL_T, bool>::value, bool>::type =
         true>
-bool extract_scalar_tensor(Tensor tensor, BOOL_T* out_val) {
+bool extract_scalar_tensor(exec_aten::Tensor tensor, BOOL_T* out_val) {
   if (tensor.scalar_type() != exec_aten::ScalarType::Bool) {
     return false;
   }