pytorch
diff --git a/‎.circleci/scripts/build_android_gradle.sh‎
Lines changed: 12 additions & 0 deletions b/‎.circleci/scripts/build_android_gradle.sh‎
Lines changed: 12 additions & 0 deletions
diff --git a/‎aten/src/ATen/Context.h‎
Lines changed: 4 additions & 4 deletions b/‎aten/src/ATen/Context.h‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎aten/src/ATen/Declarations.cwrap‎
Lines changed: 0 additions & 12 deletions b/‎aten/src/ATen/Declarations.cwrap‎
Lines changed: 0 additions & 12 deletions
diff --git a/‎aten/src/ATen/InitialTensorOptions.h‎
Lines changed: 1 addition & 1 deletion b/‎aten/src/ATen/InitialTensorOptions.h‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎aten/src/ATen/NamedTensorUtils.cpp‎
Lines changed: 51 additions & 59 deletions b/‎aten/src/ATen/NamedTensorUtils.cpp‎
Lines changed: 51 additions & 59 deletions
@@ -56,4 +56,16 @@ else
     $GRADLE_PATH -p ~/workspace/android/ assembleRelease
 fi
 
+
+find . -type f -name "*.a" -exec ls -lh {} \;
+
+while IFS= read -r -d '' file
+do
+  echo
+  echo "$file"
+  ls -lah "$file"
+  zipinfo -l "$file"
+done < <(find . -type f -name '*.aar' -print0)
+
 find . -type f -name *aar -print | xargs tar cfvz ~/workspace/android/artifacts.tgz
+
@@ -142,22 +142,22 @@ CAFFE2_API Allocator* getCPUAllocator();
 
 static inline DeprecatedTypeProperties& getNonVariableDeprecatedTypeProperties(Backend p, ScalarType s) {
   return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
-      p, s);
+      p, s, /*is_variable*/false);
 }
 
 static inline DeprecatedTypeProperties& CPU(ScalarType s) {
   return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
-      Backend::CPU, s);
+      Backend::CPU, s, /*is_variable*/false);
 }
 
 static inline DeprecatedTypeProperties& CUDA(ScalarType s) {
   return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
-      Backend::CUDA, s);
+      Backend::CUDA, s, /*is_variable*/false);
 }
 
 static inline DeprecatedTypeProperties& HIP(ScalarType s) {
   return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
-      Backend::HIP, s);
+      Backend::HIP, s, /*is_variable*/false);
 }
 
 static inline bool hasCUDA() {
 
@@ -651,18 +651,6 @@
     - bool largest
     - bool sorted
 ]]
-[[
-  name: _th_abs
-  cname: abs
-  backends:
-    - CUDA
-  variants: function
-  return: argument 0
-  arguments:
-    - arg: THTensor* result
-      output: True
-    - THTensor* self
-]]
 [[
   name: _th_exp
   cname: exp
 
@@ -9,7 +9,7 @@ namespace at {
 // NOTE: this is not a stable API.
 inline TensorOptions initialTensorOptions() {
   return TensorOptions(kCPU).dtype(kFloat).layout(kStrided)
-                            .requires_grad(false);
+                            .requires_grad(false).is_variable(false);
 }
 
 }
@@ -111,7 +111,6 @@ std::vector<Dimname> unify_from_right(
   return result;
 }
 
-
 namespace namedinference {
 
 static std::bitset<dim_bitset_size>
@@ -128,51 +127,41 @@ static void assert_names_equal(DimnameList a, DimnameList b) {
       ". Please rename the out tensor's dims with `Tensor.rename`.");
 }
 
-void propagate_names(TensorImpl* result, optional<DimnameList> names) {
-  if (!impl::has_names(result) && !names.has_value()) {
-    return;
-  }
-  if (!impl::has_names(result)) {
-    impl::internal_set_names_inplace(result, names);
-    return;
-  }
-  assert_names_equal(
-      impl::get_names(result),
-      names.value_or(default_names(result->dim())));
-}
-
-void propagate_names(
-    Tensor& result,
-    optional<std::vector<Dimname>>&& maybe_names,
+Tensor& propagate_names_if_nonempty(Tensor& result,
+    DimnameList maybe_names,
     bool validate_names) {
-  propagate_names(result.unsafeGetTensorImpl(), std::move(maybe_names), validate_names);
+  propagate_names_if_nonempty(result.unsafeGetTensorImpl(), maybe_names, validate_names);
+  return result;
 }
 
-void propagate_names(
-    TensorImpl* result,
-    optional<std::vector<Dimname>>&& maybe_names,
+TensorImpl* propagate_names_if_nonempty(TensorImpl* result,
+    DimnameList maybe_names,
     bool validate_names) {
-  if (!maybe_names) {
-    propagate_names(result, nullopt);
-    return;
-  }
-  propagate_names(result, std::move(maybe_names.value()), validate_names);
-}
-
-void propagate_names(TensorImpl* result, std::vector<Dimname>&& names, bool validate_names) {
-  if (!impl::has_names(result)) {
-    impl::internal_set_names_inplace(result, std::move(names), validate_names);
-    return;
+  if (maybe_names.empty()) {
+    return result;
   }
-  assert_names_equal(impl::get_names(result), names);
+  return propagate_names(result, maybe_names, validate_names);
 }
 
-void propagate_names(Tensor& result, optional<DimnameList> names) {
-  propagate_names(result.unsafeGetTensorImpl(), names);
+Tensor& propagate_names(Tensor& result, DimnameList names, bool validate_names) {
+  propagate_names(result.unsafeGetTensorImpl(), names, validate_names);
+  return result;
 }
 
-void propagate_names(Tensor& result, std::vector<Dimname>&& names, bool validate_names) {
-  propagate_names(result.unsafeGetTensorImpl(), std::move(names), validate_names);
+TensorImpl* propagate_names(TensorImpl* result, DimnameList names, bool validate_names) {
+  if (result->dim() > 0) {
+    TORCH_INTERNAL_ASSERT(
+        !names.empty(),
+        "propagate_names: passed in empty names to propagate to result with",
+        " shape ", result->sizes(), ". Empty names means that name inference did",
+        "not occur; use `propagate_names_if_nonempty` instead of `propagate_names`.");
+  }
+  if (!impl::has_names(result)) {
+    impl::internal_set_names_inplace(result, names, validate_names);
+  } else {
+    assert_names_equal(impl::get_names(result), names);
+  }
+  return result;
 }
 
 void propagate_names_except(Tensor& result, const Tensor& src, IntArrayRef excluded_idxs) {
@@ -188,7 +177,7 @@ void propagate_names_except(Tensor& result, const Tensor& src, IntArrayRef exclu
   if (excluded_idxs.size() == 1) {
     std::vector<Dimname> outnames = src_names.vec();
     outnames.erase(outnames.begin() + maybe_wrap_dim(excluded_idxs[0], src_dim));
-    propagate_names(result, std::move(outnames), /*validate_names=*/false);
+    propagate_names(result, outnames);
     return;
   }
 
@@ -200,7 +189,7 @@ void propagate_names_except(Tensor& result, const Tensor& src, IntArrayRef exclu
       outnames.push_back(src_names[dim]);
     }
   }
-  propagate_names(result, std::move(outnames), /*validate_names=*/false);
+  propagate_names(result, outnames);
 }
 
 void propagate_names_for_reduction(Tensor& result, const Tensor& src, IntArrayRef reduced_dims, bool keepdim) {
@@ -223,12 +212,15 @@ void propagate_names(TensorImpl* result, TensorImpl* src) {
   if (result == src) {
     return;
   }
-  propagate_names(result, impl::get_opt_names(src));
+  if (!impl::has_names(result) && !impl::has_names(src)) {
+    return;
+  }
+  propagate_names(result, impl::get_names(src));
 }
 
-optional<std::vector<Dimname>> compute_squeeze_outnames(const Tensor& tensor) {
+std::vector<Dimname> compute_squeeze_outnames(const Tensor& tensor) {
   if (!tensor.has_names()) {
-    return nullopt;
+    return {};
   }
   std::vector<Dimname> outnames;
   auto tensor_names = tensor.names();
@@ -371,7 +363,7 @@ void propagate_names_for_addmv(
   }
   auto mv_outnames = compute_matmul_outnames(impl::get_names(mat), impl::get_names(vec));
   auto add_outnames = unify_from_right(mv_outnames, impl::get_names(bias));
-  propagate_names(result, std::move(add_outnames), /*validate_names=*/false);
+  propagate_names(result, add_outnames);
 }
 
 void propagate_names_for_addmm(
@@ -385,7 +377,7 @@ void propagate_names_for_addmm(
   }
   auto mm_outnames = compute_matmul_outnames(impl::get_names(m1), impl::get_names(m2));
   auto add_outnames = unify_from_right(mm_outnames, impl::get_names(bias));
-  propagate_names(result, std::move(add_outnames), /*validate_names=*/false);
+  propagate_names(result, add_outnames);
 }
 
 void check_names_for_dot(
@@ -415,24 +407,24 @@ void propagate_names_for_expand(Tensor& result, const Tensor& self) {
       self.opt_names()->begin(),
       self.opt_names()->end(),
       outnames.begin() + result_dim - self.dim());
-  propagate_names(result, std::move(outnames), /*validate_names=*/false);
+  propagate_names(result, outnames);
 }
 
-optional<std::vector<Dimname>> compute_broadcast_outnames(
+std::vector<Dimname> compute_broadcast_outnames(
     const Tensor& self,
     const Tensor& other) {
   if (!self.has_names() && !other.has_names()) {
-    return nullopt;
+    return {};
   }
   return unify_from_right(self.names(), other.names());
 }
 
-optional<std::vector<Dimname>> broadcast_to_outnames(
+std::vector<Dimname> broadcast_to_outnames(
     const Tensor& tensor,
     const Tensor& reference_tensor,
     const char* op_name) {
   if (!tensor.has_names() && !reference_tensor.has_names()) {
-    return nullopt;
+    return {};
   }
   auto reference_names = reference_tensor.names();
   auto tensor_names = tensor.names();
@@ -445,9 +437,9 @@ optional<std::vector<Dimname>> broadcast_to_outnames(
   return unify_from_right(reference_names, tensor_names);
 }
 
-optional<std::vector<Dimname>> compute_cat_outnames(TensorList tensors) {
+std::vector<Dimname> compute_cat_outnames(TensorList tensors) {
   if (!at::has_names(tensors)) {
-    return nullopt;
+    return {};
   }
   std::vector<Dimname> result;
   for (const auto& tensor : tensors) {
@@ -461,20 +453,20 @@ optional<std::vector<Dimname>> compute_cat_outnames(TensorList tensors) {
   return result;
 }
 
-optional<std::vector<Dimname>> compute_matmul_outnames(
+std::vector<Dimname> compute_matmul_outnames(
     const Tensor& self,
     const Tensor& other) {
   if (!self.has_names() && !other.has_names()) {
-    return nullopt;
+    return {};
   }
   return compute_matmul_outnames(self.names(), other.names());
 }
 
-optional<std::vector<Dimname>> compute_cdist_outnames(
+std::vector<Dimname> compute_cdist_outnames(
     const Tensor& self,
     const Tensor& other) {
   if (!self.has_names() && !other.has_names()) {
-    return nullopt;
+    return {};
   }
   const auto self_names = self.names();
   const auto other_names = other.names();
@@ -496,24 +488,24 @@ optional<std::vector<Dimname>> compute_cdist_outnames(
   return result.toDimnameVec();
 }
 
-optional<std::vector<Dimname>> compute_bmm_outnames(
+std::vector<Dimname> compute_bmm_outnames(
     Tensor& result,
     const Tensor& self,
     const Tensor& other) {
   if (!result.has_names() && !self.has_names() && !other.has_names()) {
-    return nullopt;
+    return {};
   }
   return compute_matmul_outnames(self.names(), other.names());
 }
 
-optional<std::vector<Dimname>> compute_baddbmm_outnames(
+std::vector<Dimname> compute_baddbmm_outnames(
     TensorImpl* result,
     TensorImpl* batch1,
     TensorImpl* batch2,
     TensorImpl* bias) {
   if (!impl::has_names(result) && !impl::has_names(batch1) &&
       !impl::has_names(batch2) && !impl::has_names(bias)) {
-    return nullopt;
+    return {};
   }
   auto bmm_names = compute_matmul_outnames(
       impl::get_names(batch1), impl::get_names(batch2));
Original file line number	Diff line number	Diff line change
`@@ -142,22 +142,22 @@ CAFFE2_API Allocator* getCPUAllocator();`
`142`	`142`
`143`	`143`	`static inline DeprecatedTypeProperties& getNonVariableDeprecatedTypeProperties(Backend p, ScalarType s) {`
`144`	`144`	`return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(`
`145`		`- p, s);`
	`145`	`+ p, s, /is_variable/false);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`static inline DeprecatedTypeProperties& CPU(ScalarType s) {`
`149`	`149`	`return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(`
`150`		`- Backend::CPU, s);`
	`150`	`+ Backend::CPU, s, /is_variable/false);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`static inline DeprecatedTypeProperties& CUDA(ScalarType s) {`
`154`	`154`	`return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(`
`155`		`- Backend::CUDA, s);`
	`155`	`+ Backend::CUDA, s, /is_variable/false);`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`static inline DeprecatedTypeProperties& HIP(ScalarType s) {`
`159`	`159`	`return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(`
`160`		`- Backend::HIP, s);`
	`160`	`+ Backend::HIP, s, /is_variable/false);`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`static inline bool hasCUDA() {`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace at {`
`9`	`9`	`// NOTE: this is not a stable API.`
`10`	`10`	`inline TensorOptions initialTensorOptions() {`
`11`	`11`	`return TensorOptions(kCPU).dtype(kFloat).layout(kStrided)`
`12`		`- .requires_grad(false);`
	`12`	`+ .requires_grad(false).is_variable(false);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`}`