Fix: [ATen] add more missing moves - part 2 (pytorch#89000)

Applies some more missing std::move found by static analysis. This should improve performance and reduce unnecessary copies. This PR only targets ATen for now.

And before you ask about the edits, std::move is optimal in a ternary operator as copy ellision cannot happen one. The best thing is probably rewriting it as an if else, but ultimately this should be performant enough.
Followup to pytorch#88512 and pytorch#88514

Pull Request resolved: pytorch#89000
Approved by: https://github.com/ezyang

Author: Skylion007

aten/src/ATen/Dispatch.cpp

@@ -6,7 +6,7 @@ namespace at { namespace detail {
 void record_kernel_function_dtype(std::string name) {
   RECORD_FUNCTION_WITH_SCOPE(
         at::RecordScope::KERNEL_FUNCTION_DTYPE,
-        name,
+        std::move(name),
         c10::ArrayRef<const c10::IValue>{});
 }
 

aten/src/ATen/FunctionalInverses.cpp

@@ -3,6 +3,8 @@
 
 #include <ATen/ATen.h>
 #include <ATen/ExpandUtils.h>
+
+#include <utility>
 namespace at {
 namespace functionalization {
 
@@ -129,7 +131,7 @@ Tensor FunctionalInverses::_neg_view_copy_inverse(const Tensor& base, const Tens
 
 Tensor FunctionalInverses::as_strided_copy_inverse(const Tensor& base, const Tensor& mutated_view, bool reapply_views, at::SymIntArrayRef size, at::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset) {
     // Pessimism: we can't reapply views for as_strided_scatter.
-    return base.as_strided_scatter_symint(mutated_view, size, stride, storage_offset);
+    return base.as_strided_scatter_symint(mutated_view, size, stride, std::move(storage_offset));
 }
 
 Tensor FunctionalInverses::diagonal_copy_inverse(const Tensor& base, const Tensor& mutated_view, bool reapply_views, int64_t offset, int64_t dim1, int64_t dim2) {
@@ -175,7 +177,7 @@ Tensor FunctionalInverses::lift_fresh_copy_inverse(const Tensor& base, const Ten
 
 Tensor FunctionalInverses::slice_copy_Tensor_inverse(const Tensor& base, const Tensor& mutated_view, bool reapply_views, int64_t dim, c10::optional<c10::SymInt> start, c10::optional<c10::SymInt> end, c10::SymInt step) {
     // Pessimism: we can't reapply views for slice_scatter.
-    return base.slice_scatter_symint(mutated_view, dim, start, end, step);
+    return base.slice_scatter_symint(mutated_view, dim, std::move(start), std::move(end), std::move(step));
 }
 
 Tensor FunctionalInverses::split_copy_Tensor_inverse(const Tensor& base, const Tensor& mutated_view, bool reapply_views, int64_t mutated_view_idx, c10::SymInt split_size, int64_t dim) {

aten/src/ATen/FunctionalStorageImpl.h

@@ -33,7 +33,9 @@ struct ViewMeta {
       std::function<Tensor(const Tensor&, int64_t)> forward,
       std::function<Tensor(const Tensor&, const Tensor&, int64_t)> reverse,
       int64_t out_idx = 0)
-      : forward_fn(forward), reverse_fn(reverse), out_index(out_idx) {}
+      : forward_fn(std::move(forward)),
+        reverse_fn(std::move(reverse)),
+        out_index(out_idx) {}
 
   std::function<Tensor(const Tensor&, int64_t)> forward_fn;
   std::function<Tensor(const Tensor&, const Tensor&, int64_t)> reverse_fn;

aten/src/ATen/FunctionalTensorWrapper.cpp

@@ -564,7 +564,7 @@ std::vector<Tensor> create_functional_tensor_with_view_meta(ITensorListRef view_
 void mutate_view_meta(const at::Tensor& self, functionalization::ViewMeta meta) {
   TORCH_INTERNAL_ASSERT(at::functionalization::impl::isFunctionalTensor(self));
   auto self_impl = at::functionalization::impl::unsafeGetFunctionalWrapper(self);
-  self_impl->mutate_view_meta(meta);
+  self_impl->mutate_view_meta(std::move(meta));
 }
 
 // Note [Propagating strides in the functionalization pass]

aten/src/ATen/FunctionalizeFallbackKernel.cpp

@@ -22,6 +22,8 @@
 #include <ATen/ops/as_strided_copy.h>
 #include <ATen/ops/empty_strided_native.h>
 #include <ATen/ops/_unsafe_view.h>
+
+#include <utility>
 #endif
 
 namespace {
@@ -169,7 +171,7 @@ const at::Tensor & resize__functionalization(c10::DispatchKeySet dispatchKeySet,
       return base.as_strided_scatter(mutated_view, size, compute_contiguous_strides(size));
     }
   );
-  at::functionalization::impl::mutate_view_meta(self, view_meta);
+  at::functionalization::impl::mutate_view_meta(self, std::move(view_meta));
   return self;
 }
 
@@ -278,7 +280,7 @@ at::Tensor _unsafe_view_functionalize(const at::Tensor & self, at::SymIntArrayRe
     }
   );
 
-  auto out = at::functionalization::impl::create_functional_tensor_with_view_meta(tmp_output, self, view_meta);
+  auto out = at::functionalization::impl::create_functional_tensor_with_view_meta(tmp_output, self, std::move(view_meta));
   // See  Note [Propagating strides in the functionalization pass]
   // (for _unsafe_view, I'm just manually doing the shape inference rule here instead of calling the meta function for unsafe_view)
   auto inferred_size = at::infer_size_dv(size, self.sym_numel());

aten/src/ATen/LegacyBatchingRegistrations.cpp

@@ -8,6 +8,8 @@
 #include <c10/util/irange.h>
 #include <c10/core/SymIntArrayRef.h>
 
+#include <utility>
+
 namespace at {
 
 // NOTE: [What is a batching rule?]
@@ -143,7 +145,7 @@ Tensor binary_pointwise_batching_rule(
     logical_other = logical_other.to(result_type);
   }
   auto physical_args = BroadcastingVmapTransform::logicalToPhysical(
-      {logical_self, logical_other});
+      {std::move(logical_self), std::move(logical_other)});
   auto result = Func(physical_args[0].tensor(), physical_args[1].tensor(), args...);
   return physical_args[0].getPhysicalToLogicalMap().apply(result);
 }

aten/src/ATen/ParallelNative.cpp

@@ -12,6 +12,7 @@
 #endif // C10_MOBILE
 
 #include <atomic>
+#include <utility>
 
 #ifdef _OPENMP
 #include <omp.h>
@@ -179,7 +180,7 @@ void invoke_parallel(
     }
   };
   state.remaining = num_tasks;
-  _run_with_pool(task, num_tasks);
+  _run_with_pool(std::move(task), num_tasks);
 
   // Wait for all tasks to finish.
   {
@@ -277,7 +278,7 @@ bool in_parallel_region() {
 void intraop_launch(std::function<void()> func) {
 #ifndef C10_MOBILE
   if (!in_parallel_region() && get_num_threads() > 1) {
-    _get_intraop_pool().run(func);
+    _get_intraop_pool().run(std::move(func));
   } else {
     // execute inline if we're in parallel region
     func();

aten/src/ATen/core/custom_class.cpp

@@ -45,7 +45,7 @@ namespace torch {
 namespace detail {
 
 void record_custom_class(std::string name) {
-  RECORD_FUNCTION_WITH_SCOPE(at::RecordScope::CUSTOM_CLASS, name, c10::ArrayRef<const c10::IValue>{});
+  RECORD_FUNCTION_WITH_SCOPE(at::RecordScope::CUSTOM_CLASS, std::move(name), c10::ArrayRef<const c10::IValue>{});
 }
 
 } // namespace detail

aten/src/ATen/core/dispatch/Dispatcher.cpp

@@ -1,7 +1,8 @@
 #include <ATen/core/dispatch/Dispatcher.h>
+#include <chrono>
 #include <list>
 #include <sstream>
-#include <chrono>
+#include <utility>
 
 namespace c10 {
 
@@ -206,7 +207,7 @@ RegistrationHandleRAII Dispatcher::registerDef(FunctionSchema schema, std::strin
   TORCH_CHECK(op.operatorDef_->def_count == 0, "Tried to register an operator (", schema, ") with the same name and overload name multiple times.",
                                                     " Each overload's schema should only be registered with a single call to def().",
                                                     " Duplicate registration: ", debug, ". Original registration: ", op.operatorDef_->op.debug());
-  op.operatorDef_->op.registerSchema(std::move(schema), std::move(debug), tags);
+  op.operatorDef_->op.registerSchema(std::move(schema), std::move(debug), std::move(tags));
   listeners_->callOnOperatorRegistered(op);
 
   // NB: do not increment the counts until AFTER error checking

aten/src/ATen/core/function_schema.cpp

@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <stack>
+#include <utility>
 
 namespace c10 {
 
@@ -132,7 +133,7 @@ c10::optional<AliasTypeSet> FunctionSchema::mapTypeToAliasTypeSet(const TypePtr&
       if (mutable_types.size() == 0) {
         return c10::nullopt;
       }
-      return {AliasTypeSet{TupleType::create(mutable_types)}};
+      return {AliasTypeSet{TupleType::create(std::move(mutable_types))}};
     }
     default:
       return c10::nullopt;

aten/src/ATen/core/ivalue.cpp

@@ -1,17 +1,18 @@
-#include <ATen/core/ivalue.h>
 #include <ATen/core/Dict.h>
 #include <ATen/core/Formatting.h>
 #include <ATen/core/class_type.h>
 #include <ATen/core/enum_type.h>
 #include <ATen/core/function.h>
+#include <ATen/core/ivalue.h>
 #include <ATen/core/jit_type.h>
 #include <ATen/core/stack.h>
 #include <ATen/core/type_factory.h>
-#include <c10/util/irange.h>
 #include <c10/util/StringUtil.h>
 #include <c10/util/hash.h>
+#include <c10/util/irange.h>
 #include <cmath>
 #include <iostream>
+#include <utility>
 
 namespace c10 {
 bool _fastEqualsForContainer(const IValue& lhs, const IValue& rhs) {
@@ -492,11 +493,11 @@ std::ostream& printMaybeAnnotatedList(
   if (the_list.toListRef().size() == 0 ||
       !elementTypeCanBeInferredFromMembers(list_elem_type)) {
     out << "annotate(" << the_list.type<c10::Type>()->annotation_str() << ", ";
-    printList(out, the_list.toListRef(), "[", "]", formatter);
+    printList(out, the_list.toListRef(), "[", "]", std::move(formatter));
     out << ")";
     return out;
   } else {
-    return printList(out, the_list.toListRef(), "[", "]", formatter);
+    return printList(out, the_list.toListRef(), "[", "]", std::move(formatter));
   }
 }
 
@@ -533,9 +534,9 @@ std::ostream& printMaybeAnnotatedDict(
   if (the_dict.toGenericDict().size() == 0 ||
       !elementTypeCanBeInferredFromMembers(value_type)) {
     out << "annotate(" << the_dict.type<c10::Type>()->annotation_str() << ",";
-    printDict(out, the_dict.toGenericDict(), formatter) << ")";
+    printDict(out, the_dict.toGenericDict(), std::move(formatter)) << ")";
   } else {
-    return printDict(out, the_dict.toGenericDict(), formatter);
+    return printDict(out, the_dict.toGenericDict(), std::move(formatter));
   }
   return out;
 }
@@ -873,7 +874,7 @@ IValue IValue::deepcopy(
       for (const auto& e : toTupleRef().elements()) {
         copied_tuple.push_back(e.deepcopy(memo));
       }
-      copy = IValue(ivalue::Tuple::create(copied_tuple));
+      copy = IValue(ivalue::Tuple::create(std::move(copied_tuple)));
     }
       break;
     case IValue::Tag::GenericList: {
@@ -1033,7 +1034,7 @@ WeakTypePtr WeakOrStrongTypePtr::asWeakTypePtr() const {
   } else {
     std::weak_ptr<torch::jit::CompilationUnit> weak_cu =
         cu_.getStrongRefOrThrow();
-    return WeakTypePtr(weak_cu, type_);
+    return WeakTypePtr(std::move(weak_cu), type_);
   }
 }
 

aten/src/ATen/core/tensor_type.cpp

@@ -1,6 +1,8 @@
 #include <ATen/core/Tensor.h>
 #include <ATen/core/jit_type.h>
 
+#include <utility>
+
 namespace c10 {
 
 namespace {
@@ -416,7 +418,7 @@ VaryingShape<int64_t> TensorType::strides() const {
       ss[*s.stride_index_] = *s.stride_;
     }
   }
-  return VaryingShape<int64_t>(ss);
+  return VaryingShape<int64_t>(std::move(ss));
 }
 
 TensorType::TensorType(

aten/src/ATen/core/type.cpp

@@ -1,15 +1,15 @@
 #include <ATen/core/Dict.h>
 #include <ATen/core/Tensor.h>
 #include <ATen/core/dynamic_type.h>
-#include <ATen/core/function_schema.h>
 #include <ATen/core/enum_type.h>
+#include <ATen/core/function.h>
 #include <ATen/core/function_schema.h>
+#include <ATen/core/grad_mode.h>
 #include <ATen/core/jit_type.h>
 #include <c10/macros/Macros.h>
 #include <c10/util/irange.h>
-#include <ATen/core/grad_mode.h>
-#include <ATen/core/function.h>
 #include <iostream>
+#include <utility>
 
 namespace std {
 template<>
@@ -298,7 +298,7 @@ TypePtr DictType::get(std::string identifier, TypePtr key, TypePtr value) {
   auto map_key = std::make_tuple(identifier, key, value);
   std::lock_guard<std::mutex> lock(mutex);
   if (containerTypePtrs.find(map_key) == containerTypePtrs.end()) {
-    TypePtr t = DictType::create(key, value);
+    TypePtr t = DictType::create(std::move(key), std::move(value));
     containerTypePtrs.emplace(map_key, std::move(t));
   }
   return containerTypePtrs[map_key];
@@ -738,7 +738,7 @@ TupleTypePtr TupleType::createWithSpec(const c10::optional<c10::QualifiedName>&
       /*arguments=*/std::move(arguments),
       /*returns=*/std::vector<Argument>{});
   return std::shared_ptr<TupleType>(new TupleType(
-      field_types, qualName, schema)); // NOLINT(modernize-make-shared)
+      field_types, qualName, std::move(schema))); // NOLINT(modernize-make-shared)
 }
 
 c10::optional<std::vector<c10::string_view>> TupleType::names() const {

aten/src/ATen/core/union_type.cpp

@@ -1,13 +1,14 @@
 #include <ATen/core/Dict.h>
 #include <ATen/core/Tensor.h>
+#include <ATen/core/function.h>
 #include <ATen/core/function_schema.h>
+#include <ATen/core/grad_mode.h>
 #include <ATen/core/jit_type.h>
 #include <ATen/core/type_factory.h>
 #include <c10/macros/Macros.h>
 #include <c10/util/irange.h>
-#include <ATen/core/grad_mode.h>
-#include <ATen/core/function.h>
 #include <iostream>
+#include <utility>
 
 namespace c10 {
 
@@ -262,7 +263,7 @@ UnionTypePtr UnionType::create(std::vector<TypePtr> reference) {
       auto not_none = union_type->containedTypes()[0] != NoneType::get()
                       ? union_type->containedTypes()[0]
                       : union_type->containedTypes()[1];
-      return OptionalType::create(not_none);
+      return OptionalType::create(std::move(not_none));
     }
   }
 
@@ -396,7 +397,7 @@ std::string UnionType::unionStr(TypePrinter printer, bool is_annotation_str)
       ss << ", ";
     }
     if (is_annotation_str) {
-      ss << NumberType::get()->annotation_str(printer);
+      ss << NumberType::get()->annotation_str(std::move(printer));
     } else {
       ss << NumberType::get()->str();
     }
@@ -410,7 +411,7 @@ std::string UnionType::str() const {
 }
 
 std::string UnionType::annotation_str_impl(TypePrinter printer) const {
-  return this->unionStr(printer, /*is_annotation_str=*/true);
+  return this->unionStr(std::move(printer), /*is_annotation_str=*/true);
 }
 
 bool UnionType::canHoldType(const Type& type) const {

aten/src/ATen/native/Activation.cpp

@@ -73,6 +73,8 @@
 #include <ATen/ops/threshold_backward_native.h>
 #include <ATen/ops/threshold_native.h>
 #include <ATen/ops/zeros_like.h>
+
+#include <utility>
 #endif
 
 namespace at {
@@ -624,7 +626,7 @@ Tensor rrelu_with_noise_cpu(
     c10::optional<Generator> generator) {
   auto output = at::empty_like(self, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
   return at::native::rrelu_with_noise_out_cpu(
-      self, noise, lower, upper, training, generator, output);
+      self, noise, lower, upper, training, std::move(generator), output);
 }
 
 Tensor& rrelu_with_noise_cpu_(
@@ -635,7 +637,7 @@ Tensor& rrelu_with_noise_cpu_(
     bool training,
     c10::optional<Generator> generator) {
   return at::native::rrelu_with_noise_out_cpu(
-      self, noise, lower, upper, training, generator, self);
+      self, noise, lower, upper, training, std::move(generator), self);
 }
 
 Tensor rrelu_with_noise_backward(
@@ -658,12 +660,12 @@ Tensor rrelu_with_noise_backward(
 
 Tensor rrelu(const Tensor & self, const Scalar& lower, const Scalar& upper, bool training, c10::optional<Generator> generator) {
   TORCH_CHECK(lower.to<double>() <= upper.to<double>(), "Lower bound should be less than or equal to the upper bound")
-  return at::rrelu_with_noise(self, at::empty_like(self, LEGACY_CONTIGUOUS_MEMORY_FORMAT), lower, upper, training, generator);
+  return at::rrelu_with_noise(self, at::empty_like(self, LEGACY_CONTIGUOUS_MEMORY_FORMAT), lower, upper, training, std::move(generator));
 }
 
 Tensor & rrelu_(Tensor & self, const Scalar& lower, const Scalar& upper, bool training, c10::optional<Generator> generator) {
   TORCH_CHECK(lower.to<double>() <= upper.to<double>(), "Lower bound should be less than or equal to the upper bound")
-  return at::rrelu_with_noise_(self, at::empty_like(self, LEGACY_CONTIGUOUS_MEMORY_FORMAT), lower, upper, training, generator);
+  return at::rrelu_with_noise_(self, at::empty_like(self, LEGACY_CONTIGUOUS_MEMORY_FORMAT), lower, upper, training, std::move(generator));
 }
 
 TORCH_IMPL_FUNC(threshold_out)(const Tensor& self, const Scalar& threshold, const Scalar& value, const Tensor& result) {